def read_config(config_file=""): config = {} if config_file == "": file = open("/home/pi/fireball_camera/config.txt", "r") else: file = open(config_file, "r") for line in file: line = line.strip('\n') #print (line) #Find first index of = c = line.index('=') config[line[0:c]] = line[c + 1:] try: test = config['hd'] except: config['hd'] = 0 if 'cam_pwd' in config: try: #We decrypt the cam password if it is crypted c = Crypt() config['cam_pwd'] = c.decrypt(config['cam_pwd']) except: config['cam_pwd'] = config['cam_pwd'] else: config['cam_pwd'] = 'xrp23q' file.close() return (config)
def write_config(config, config_file=""): if len(config) < 3: print("Error not enough config vars passed.") exit() if config_file == "": file = open("/home/pi/fireball_camera/config.txt", "w") else: file = open(config_file, "w") for key in config: if key == 'cam_pwd': try: #We ecrypt the cam password if it is not crypted c = Crypt() temp = c.decrypt(config['cam_pwd']) except: config['cam_pwd'] = c.encrypt(config['cam_pwd']) if key != 'IP': if key == 'cam_ip' and config[key] == '192.168.1.88': print("skip.") else: line = key + "=" + str(config[key]) + "\n" file.write(line) file.close() print("Config written.")
class CDMAClient(Client): """ A CDMA client """ handlers = [] chip = '' def __init__(self, name, host = 'localhost', port = 10000): Client.__init__(self, host, port) self.name = name self.crypt = Crypt() self.handlers = [self.socket, sys.stdin] def run(self): self.send(sys.argv[1]) self.chip = self.socket.recv(1024) if self.chip == 'NNNN': raise ValueError() else: print 'client ' + self.name + ' got chip ' + self.chip while True: readable, writeable, ex = select.select(self.handlers, [], []) for r in readable: if r == sys.stdin: input = raw_input().split(' ') self.socket.send(input[0]) addresseeChip = self.socket.recv(1024) self.socket.send(self.crypt.encrypt(addresseeChip, input[1])) else: data = r.recv(1024) print 'received: ' + self.crypt.decrypt(self.chip, data)
def test_ed_cycle(self): for pt, pph in d_values: c = Crypt(pph) u = c.encrypt(pt) dc = c.decrypt(u) print "assert equal: %s == %s" % (dc, str(pt)) self.assertEqual(dc, str(pt))
def decrypt_text(self, gui, password_entry): textentry = self.get_current_textview(gui) password = password_entry.get_text() textbuffer = Gtk.TextBuffer() textbuffer = textentry.get_buffer() buffer_start = textbuffer.get_start_iter() buffer_end = textbuffer.get_end_iter() content = textbuffer.get_text(buffer_start, buffer_end, True) key = password Cipher = Crypt() content_decrypted = Cipher.decrypt(key, content) try: textbuffer.set_text(content_decrypted) textentry.set_buffer(textbuffer) except TypeError: print("Type Error")
def read_config(): logging.debug('Reading Config.txt') config = {} try: file = open("/home/pi/fireball_camera/config.txt", "r") for line in file: line = line.strip('\n') #Find first index of = if('=' in line): c = line.index('=') config[line[0:c]] = line[c+1:] config['hd'] = 0 if 'cam_pwd' in config: try: #We decrypt the cam password if it is crypted c = Crypt() config['cam_pwd'] = c.decrypt(config['cam_pwd']) logging.debug('cam_pwd successfully decrypted') except: config['error'] = "Impossible to decrypt the password - password must only contains characters and digits" logging.error('Impossible to decrypt ' + str(config['cam_pwd'])) logging.debug('Config (ERROR) ' + str(config)) file.close() logging.debug('Result ' + str(config) ) return(config) except: config['error'] = 'The config file cannot be read, please check your config.txt file'; logging.error('Error in config.txt') logging.debug('Config (ERROR) ' + str(config)) return config;
class Leaderboards: """ Main game class. """ def __init__(self, max_clients, db_name, db_host, db_port, secret): """ Constructor. """ # self.server_status = 'not ready' self.db_name = db_name self.db_host = db_host self.db_port = db_port # self.db_reconnect() self.db = Db(self, self.db_name, self.db_host, self.db_port) # Restart DB connection in looping call #self.lc = LoopingCall(self.db_reconnect) #self.lc.start(300) # Sequence bellow showld be the same as on client application #self.sequence = [99, 143, 127, 182, 214, 17, 76, 92, 213, 199, 7, 43, 73, 197, 193, 5, 14, 88, 231, 94, 1, 183, 91, 191, 19, 237, 7, 85, 172, 41, 97, 29, 61, 111, 222] self.sequence = secret self.base64_alt = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' log.msg(secret) self.apps = [] self.clients = {} self.max_clients = max_clients # self.db = Db(self, db_name, db_host, db_port) self.crypt = Crypt(self.sequence) #def db_reconnect(self): # self.server_status = 'not ready' # self.db = None # self.db = Db(self, self.db_name, self.db_host, self.db_port) def _on_db_init_response(self, value, apps): """ Callback for DB initialization function (class Db). """ self.apps = apps if len(self.apps): self.server_status = 'ready' log.msg('DB connection established (updated)') def checkServerStatus(self): """ Tis function calls from class LeaderboardsProtocol pn connectionMade method to check if server ready to process user data or not. """ if self.server_status != 'ready' or len(self.clients) > self.max_clients: return False return True def initClient(self, client, addr): """ Save connected user data. """ client.client_id = addr.port client.host = addr.host client.server_status = self.server_status client.chunks_amount = None client.chunks = None client.data = '' client.mode = None client.game_type = None client.max_score = 0 client.best_item = None client.top = [] client.best_item_place = None log_msg = 'class Leadreboards, client %s initialized' % (client.client_id,) log.msg(log_msg) # Add new client to global dictionary self.clients[client.client_id] = client return client def processUserRecords(self, client_id, data): #log.msg('processUserRecords: received data') #log.msg(len(data)) #log.msg(data) decoded_data = self.decodeUserRecords(data) #log.msg('decrypted') #log.msg(decoded_data) user_results = json.loads(decoded_data) self.clients[client_id].mode = mode = user_results.get('mode', None) self.clients[client_id].game_type = game_type = user_results.get('game_type', 'tetcolor') app_name = user_results.get('app_name', None) app_secret = user_results.get('app_secret', None) results = user_results.get('local_records', None) # TODO: uncomment this line after update of all clients # if game_type is None or mode is None or app_name is None or app_secret is None or results is None: if mode is None or app_name is None or app_secret is None or results is None: log.msg('Wrong request for %s, %s, %s' % (mode, app_name, app_secret)) return 'wrong request' app_check = False for app in self.apps: if app['name'] == app_name and app['secret'] == app_secret: app_check = True if not app_check: return 'wrong arguments' #log.msg(app_name) #log.msg(app_secret) import base64 items = [] for result in results: if isinstance(result, dict): name = result.get('name', None) score = result.get('value', None) record_id = result.get('record_id', None) if name is not None and score is not None and record_id is not None: #name = self.crypt(name, True) name = base64.b64decode(name) timestamp = int(time.time()) item = {} item['name'] = name item['score'] = score item['timestamp'] = timestamp item['record_id'] = record_id if self.clients[client_id].game_type != 'tetcolor': item['mode'] = self.clients[client_id].game_type + '_' + mode else: item['mode'] = mode print('current best ' + str(self.clients[client_id].max_score) + '; score ' + str(score)) if int(score) > int(self.clients[client_id].max_score): print('set this item as best because ' + str(score) + ' gt ' + str(self.clients[client_id].max_score)) self.clients[client_id].max_score = score self.clients[client_id].best_item = item items.append(item) self.db.check_unique_and_insert(items, self.clients[client_id].host)\ .addCallback(self._on_db_insert_response, client_id)\ .addErrback(self._on_db_error, client_id) return 'wait for db' def _on_db_insert_response(self, value, client_id): """ Callback for DB insert function (class Db). """ log.msg('Data inserted for client ' + str(client_id)) self.retrieveTopResults(client_id) def retrieveTopResults(self, client_id): """ Retrieve best results from DB and send to client, """ self.db.get_top(client_id, self.clients[client_id].mode, self.clients[client_id].game_type)\ .addCallback(self._on_db_get_top_response, client_id)\ .addErrback(self._on_db_error, client_id) def _on_db_get_top_response(self, value, client_id): #log.msg('top10 number ' + str(len(self.clients[client_id].top))) #log.msg(str(self.clients[client_id].top[0]['name'])) #for result in self.clients[client_id].top: # log.msg('top item: ' + unicode(result['name']) + ' ' + str(result['score'])) if self.clients[client_id].best_item is None or self.clients[client_id].best_item['score'] is None: score = 0 self.clients[client_id].best_item = {} self.clients[client_id].best_item['score'] = 0 self.clients[client_id].best_item['record_id'] = 'some-unexisting-value' else: score = self.clients[client_id].best_item['score'] self.db.get_user_best(client_id, score, self.clients[client_id].mode, self.clients[client_id].game_type)\ .addCallback(self._on_db_get_user_best_response, client_id)\ .addErrback(self._on_db_error, client_id) def _on_db_get_user_best_response(self, value, client_id): log.msg('best score ' + str(self.clients[client_id].best_item['score'])) log.msg('best id ' + self.clients[client_id].best_item['record_id']) log.msg('best place ' + str(self.clients[client_id].best_item_place)) self.send_data_and_close_connection(client_id) def send_data_and_close_connection(self, client_id): result = {} result['top'] = self.clients[client_id].top result['place'] = self.clients[client_id].best_item_place j = json.dumps(result) c = self.crypt.crypt(j) self.clients[client_id].writeData(c) self.clients[client_id].transport.loseConnection() del self.clients[client_id] def _on_db_init_error(self, value): """ DB initialization errorback. """ log.msg('DB init errorback. Something went wrong in DB') def _on_db_error(self, value, client_id): """ Errorback for client interaction with DB. """ log.msg('DB errorback. Something went wrong in DB: ' + str(value)) self.clients[client_id].writeData('4') self.clients[client_id].transport.loseConnection() def decodeUserRecords(self, data): log.msg('decodeUserRecords') return self.crypt.decrypt(data)
class Backup: """Handles complete backup flow. Check if file exists orhas been modified. Compresses, encrypts and uploads the file to th destination.""" db = None job = None compress = None encrypt = None def __init__(self, job, db): self.job = job self.db = db self.archive = Archive() self.crypt = Crypt() def backup(self): """Start backup process.""" if not isdir(self.job['path']): self._list_files( None, dirname(self.job['path']), [basename(self.job['path']), ] ) else: walk(self.job['path'], self._list_files, None) def _list_files(self, dir, basepath, files): """Callback for walker. Iterates over filelist, builds absolute path and checks wheather to skip or upload the file.""" for file in files: # absolute path path = join(basepath, file) # only work on files if isfile(path) or ( not isdir(path) and self.job.has_key('pre_command')): item = self.db.get_file(self.job['name'], path) # file is not in db if not item: self._backup_file(path) else: # file exists in db, but has a different mtime if isfile(path): mtime = getmtime(path) if int(item['mtime']) != int(mtime): self._backup_file(path) else: self._backup_file(path) def _execute_command(self, command): """Execute pre- or postcommand.""" if self.job.has_key(command): try: logging.info('[%s] Executing %s' % (self.job['name'], self.job[command])) system(self.job[command]) except: logging.warn('[%s] Command failed %s' % (self.job['name'], self.job[command])) def _backup_file(self, path): """Back ups specific file to desired storage device.""" print('[%s] Starting backup for %s' % (self.job['name'], path)) # precommand self._execute_command('pre_command') # get size, mtime file_info = self._file_info(path) # get storeage wrapper storage = self._get_account(self.job['destination']) dest = join(tempfile.gettempdir(), 'umaticssync') # is compression deired? bzip2 file if self.job.has_key('compress') and self.job['compress'] == 'true': logging.info('[%s] Compressing %s' % (self.job['name'], path)) self.archive.compress(path, dest) old_dest = dest compressed = 1 # is encryption desired? encrypt with user id if self.job.has_key('encrypt') and self.job['encrypt']: logging.info('[%s] Encrypting %s' % (self.job['name'], path)) self.crypt.encrypt(self.job['encrypt'], dest) dest = dest + '.gpg' remove(old_dest) encrypted = 1 # add file/increase revision info = self.db.add_file( self.job['name'], path, file_info['mtime'], file_info['size'], encrypted, compressed) # build key and upload, cleanup key = normpath('%s/%s.r%%s' % (self.job['name'], path)) logging.info('[%s] Uploading %s.r%s' % (self.job['name'], path, info['revision'])) storage.store_file(key % info['revision'], dest) remove(dest) # cleanup old revisions revision = int(info['revision']) - int(self.job['revisions']) if revision >= 0: print "del", key % revision storage.del_file(key % revision) # postcommand self._execute_command('post_command') def _file_info(self, path): """Returns size and mtime.""" return {'size': getsize(path), 'mtime': getmtime(path)} def _get_account(self, uri): """Return storage engine object based on the provided URI string.""" uri = urlsplit(uri) # s3 backend if uri[0] == 's3': a_key, s_key = uri[2][2:].split('@')[0].split(':') bucket = uri[2][2:].split('@')[1] from wrapper.S3Wrapper import S3Wrapper return S3Wrapper(a_key, s_key, bucket) # ftp server elif uri[0] == 'ftp': user, passwd = uri[2][2:].split('@')[0].split(':') host = uri[2][2:].split('@')[1] path = uri[2] from wrapper.FTPWrapper import FTPWrapper return FTPWrapper(host, user, passwd, path) # @todo: implement elif uri[0] == 'scp': pass # local storage backend elif uri[0] == 'file': path = uri[1] from wrapper.FileWrapper import FileWrapper return FileWrapper(path) def restore(self, revision): files = self.db.get_files(self.job['name']) if len(files) == 0: #logging.info('[%s] No files found for backup job') return False # get storage instance storage = self._get_account(self.job['destination']) # iterate thur files for file in files: try: # is given revision in allowed range? rev_diff = int(file['revision']) - int(self.job['revisions']) if int(revision) in range(rev_diff, file['revision'] + 1): rev = revision else: # fallback to latest file revision rev = file['revision'] except: rev = file['revision'] logging.info('[%s] Restoring %s.r%s' % (self.job['name'], file['path'], rev)) # get file key = normpath('%s/%s.r%s' % (self.job['name'], file['path'], rev)) dest = join(tempfile.gettempdir(), 'umaticssync') logging.info('[%s] Downloading %s' % (self.job['name'], file['path'])) storage.get_file(key, dest) if file['encrypted'] == 1: logging.info('[%s] Decrypting %s' % (self.job['name'], file['path'])) self.crypt.decrypt(self.job['encrypt'], dest, dest) if file['compressed'] == 1: logging.info('[%S] Extracting %s' % (self.job['name'], file['path'])) self.archive.extract(dest) else: rename(dest, file['path'])
from base64 import b64decode from crypt import Crypt p = b64decode('=i') x = Crypt(p) src = '/Users/nbari/.ftrunk/eb/c5/99/ebc5999af324a1f4272e15795690cb979dbea921a56fbd4957f5f83055bb7c04363d35bf475856637f0ff0929400507f1e998b7c709dae1de53748ab5f3381ca' with open(src, 'rb') as in_file, open('/tmp/out.bz2', 'wb') as out_file: x.decrypt(in_file, out_file)
from crypt import Crypt c = Crypt() a = c.encrypt('12345') print(a) b = c.decrypt(a) print(b)
def encout(filename, data): with open(filename, 'w') as outfile: outfile.write(data) def decin(filename): data = open(filename).read() return data #################################################################################################### ## file read #################################################################################################### fileobj = open(sys.argv[1]) msg = bytes(fileobj.read(), "utf-8") #################################################################################################### ccc = Crypt() key = bytes(sys.argv[1], "utf-8") #encrypted = ccc.encrypt(key, msg) #decrypted = ccc.decrypt(key, encrypted) #encout('enc_' + sys.argv[1], encrypted) fileenc = decin('enc_test') decrypted = ccc.decrypt(key, fileenc) #print(encrypted) print(decrypted)
def test_decrypt(self): c = Crypt(self.cipher_key) decrypted = c.decrypt('3b1b943Dcrqm179NGt3GnA==') assert decrypted == 'ace to the base'
class Api: """ Deal with API requests and local clipboard """ SERVER = None USER = None HASH_LOGIN = None HASH_MSG = None crypto = None def __init__(self, server, user, hash_login, hash_msg): self.SERVER = server self.USER = user self.HASH_LOGIN = hash_login self.HASH_MSG = hash_msg self.crypto = Crypt(username=user, password=None, hash_login=hash_login, hash_msg=hash_msg) def upload(self): """ Send the copied text to SERVER """ clip = self.copy() clip_encrypted = self.crypto.encrypt(clip) payload = {"text": clip_encrypted, "device": f"{Config.DEVICE_ID}"} try: res = requests.post( self.SERVER + Config.API_COPY_PASTE, data=payload, auth=(self.USER, self.HASH_LOGIN), timeout=Config.CONN_TIMEOUT, verify=Config.VERIFY_SSL_CERT, headers=Config.HEADERS, ) except requests.exceptions.RequestException as e: log.exception("Error in upload request") raise ApiException(e) else: if res.status_code == 201: log.info("Success! Copied to Cloud-Clipboard.") return clip else: log.error(f"Error cannot upload clip: {res.text}") raise ApiException(res.text[0:Config.MAX_RESPONSE_LEN]) def download(self): """ Download last or all clips from SERVER and updates the local clipboard """ log.info("downloading clips") url = self.SERVER + Config.API_COPY_PASTE try: res = requests.get( url=url, auth=(self.USER, self.HASH_LOGIN), timeout=Config.CONN_TIMEOUT, verify=Config.VERIFY_SSL_CERT, headers=Config.HEADERS, ) except requests.exceptions.RequestException as e: log.exception("Error in download request") raise ApiException(e) else: if res.status_code == 200: clips_decrypted = self.parse_and_decrypt_response(res) log.info(f"Got new clips from SERVER:\n{clips_decrypted}") self.paste(clips_decrypted[-1]) return clips_decrypted else: log.error( f"Cannot download clips: {res.status_code} - {res.text}") raise ApiException(res.text[0:Config.MAX_RESPONSE_LEN]) def parse_and_decrypt_response(self, response): """ Parse list clip response and decrypt content Returns: List: Contains one or more clips. Ordered by creation date (DESC) """ clips_decrypted = [] try: clips = json.loads(response.text) for clip in clips: clips_decrypted.append(self.crypto.decrypt(clip["text"])) if len(clips) == 0: clips_decrypted = ["There are no shared Clips yet"] except Exception as e: log.e(f"Could not parse and decrypt: {e}") clips_decrypted = [""] return clips_decrypted @staticmethod def paste(data): """ Copies 'data' to local clipboard which enables pasting. """ pyperclip.copy(data) @staticmethod def copy(): """ Return the current clipboard text """ data = pyperclip.paste() return data @staticmethod def register(server, user, pw): """ register user on server using hash generated from pw """ crypto = Crypt(user, pw) login_hash = crypto.pw_hash_login payload = {"username": user, "password": login_hash} try: res = requests.post( server + Config.API_REGISTER, data=payload, timeout=Config.CONN_TIMEOUT, verify=Config.VERIFY_SSL_CERT, headers=Config.HEADERS, ) except requests.exceptions.RequestException as e: log.exception("Error in register request") raise RegisterException(e) if res.status_code == 201: log.info(f"Hi {user}! You are all set.") return True else: log.error(f"Cannot register user: {res.status_code} - {res.text}") raise RegisterException(res.text[0:Config.MAX_RESPONSE_LEN]) @staticmethod def login(server, user, pw): """ authenticate user using hash generated from pw """ crypto = Crypt(user, pw) login_hash = crypto.pw_hash_login try: res = requests.get( server + Config.API_LOGIN, auth=(user, login_hash), timeout=Config.CONN_TIMEOUT, verify=Config.VERIFY_SSL_CERT, headers=Config.HEADERS, ) except requests.exceptions.RequestException as e: log.exception("Error in login request") raise LoginException(e) if res.status_code >= 200 and res.status_code < 400: log.info("Login successful") return True else: log.error(f"Login failed: {res.status_code} - {res.text}") raise LoginException(res.text[0:Config.MAX_RESPONSE_LEN])
def get_assignments(): print(ascii_art.return_ascii()) print('Tentando encontrar o Bearer token...\n') c = Crypt() encrypted_token_file = open('token.txt', 'rb') encrypted_token = encrypted_token_file.read() encrypted_token_file.close() if not encrypted_token: print( f'{Fore.YELLOW}Não conseguimos localizar seu token salvo em cache, digite manualmente{Style.RESET_ALL}' ) print('Digite o seu bearer token do Teams: ') bearer_token = str(input('')).strip() print('\n') print(Fore.YELLOW + '!' + Style.RESET_ALL) print( Fore.YELLOW + 'Não se preocupe, não enviaremos essa informação para nenhum local, apenas será encriptada na sua máquina como cache.' + Style.RESET_ALL) print(Fore.YELLOW + '!' + Style.RESET_ALL) print('\n') key_file = open('key.key', 'rb') key = key_file.read() key_file.close() if not key: c.generate_new_key() c.encrypt(bearer_token) else: c.encrypt(bearer_token) encrypted_token_file = open('token.txt', 'rb') encrypted_token = encrypted_token_file.read() encrypted_token_file.close() if not encrypted_token: print( f'{Fore.RED}Ocorreu um erro, tente novamente{Style.RESET_ALL}') original_token = c.decrypt(encrypted_token) else: try: original_token = c.decrypt(encrypted_token) except Exception as err: print(f'{Fore.RED}{err}{Style.RESET_ALL}') clear_token() exit() print( f'{Fore.BLUE}Seu token foi encontrado em cache!{Style.RESET_ALL}\n' ) print('Pegando assignments... (Isso pode demorar alguns minutos)\n') ts = TeamScrap(original_token) try: classes_assignments = ts.get_all_classes_assignments() except Exception as err: print(f'{Fore.RED}{err}{Style.RESET_ALL}\n') print( f'{Fore.RED}Verifique se o token não expirou ou está correto{Style.RESET_ALL}\n' ) clear_token() exit() overdue_assignments = 0 print('=' * 100) message = "" for class_assignment in classes_assignments: created_date_time = class_assignment['assignmentInfo'][ 'createdDateTime'] [created_date_parsed, created_hours_parsed] = parse_teams_date_time(created_date_time) created_date_final = datetime(year=int(created_date_parsed[0]), month=int(created_date_parsed[1]), day=int(created_date_parsed[2])) bimester_init_date = datetime(year=int(2021), month=int(2), day=int(1)) if created_date_final > bimester_init_date: due_date_time = class_assignment['assignmentInfo']['dueDateTime'] [date_parsed, hours_parsed] = parse_teams_date_time(due_date_time) date_init = datetime.now() date_final = datetime(year=int(date_parsed[0]), month=int(date_parsed[1]), day=int(date_parsed[2]), hour=int(hours_parsed[0]), minute=int(hours_parsed[1]), second=int(hours_parsed[2])) date_final -= timedelta(hours=3) [final_date_parsed, final_hours_parsed] = parse_date_time(date_final) remaining_date = date_final - date_init remaining_date_parsed = str(remaining_date).split(',') message += f"""\n\n📝 Tarefa: {class_assignment['assignmentInfo']['displayName']} \n📚 Disciplina: {class_assignment["classInfo"][0]["name"]} \n⏳ Data de entrega: {final_date_parsed[2]}/{final_date_parsed[1]}/{final_date_parsed[0]} às {final_hours_parsed[0]}:{final_hours_parsed[1]}:{final_hours_parsed[2]}""" if class_assignment['assignmentInfo'][ 'allowLateSubmissions'] == 'true': message += "\n⏰ Aceita atrasos: ✅SIM✅" else: message += "\n⏰ Aceita atrasos: ❌NÃO❌" if len(remaining_date_parsed) > 1: remaining_days = int( remaining_date_parsed[0].strip().split(' ')[0]) remaining_hours = remaining_date_parsed[1].strip().split(':') else: remaining_hours = remaining_date_parsed[0].strip().split(':') if int(remaining_days) < 0: message += "\n⚙️ Status: ⌛️VENCIDA⌛️" else: message += "\n⚙️ Status: 🏃CORRE QUE DÁ TEMPO🏃" message += "\n" + "=" * 10 else: pass return message
ippacket = decoder.decode(buf) icmppacket = ippacket.child() # imcoming command incoming_src, incoming_dst = ippacket.get_ip_src(), ippacket.get_ip_dst() if icmppacket.get_icmp_type() == 8: if (server and incoming_src != server) or (client and incoming_dst != client): continue # Get identifier and sequence number icmp_id = icmppacket.get_icmp_id() seq_id = icmppacket.get_icmp_seq() data = icmppacket.get_data_as_string() try: msg = encryptor.decrypt(data).decode('utf8') if msg.startswith(MSG_ONLINE): uid = msg[len(MSG_ONLINE):] code = auth_code(uid) if code: server = incoming_src client = incoming_dst print "Server: %s" % server reply = code else: sys.stdout.write(msg) except: pass if not reply:
key_file.close() if not key: c.generate_new_key() c.encrypt(bearer_token) else: c.encrypt(bearer_token) encrypted_token_file = open('token.txt', 'rb') encrypted_token = encrypted_token_file.read() encrypted_token_file.close() if not encrypted_token: print(f'{Fore.RED}Ocorreu um erro, tente novamente{Style.RESET_ALL}') original_token = c.decrypt(encrypted_token) else: try: original_token = c.decrypt(encrypted_token) except Exception as err: print(f'{Fore.RED}{err}{Style.RESET_ALL}') clear_token() exit() print(f'{Fore.BLUE}Seu token foi encontrado em cache!{Style.RESET_ALL}\n') print('Pegando assignments... (Isso pode demorar alguns minutos)\n') ts = TeamScrap(original_token) try:
def get_clear_password(host, user, password): key = host + user s1 = sha1() s1.update(key.encode()) key = s1.digest() return Crypt.decrypt(password, key[:16])