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 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.")
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 encrypt_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_crypted = Cipher.encrypt(key, content) try: textbuffer.set_text(content_crypted) textentry.set_buffer(textbuffer) except TypeError: print("Type Error")
def add_to_config(param,new_value): #Read Current Config if(param!='cam_pwd'): config = read_config_raw(); logging.debug('Try to update the config file with ' + str(param) + ' = ' + str(new_value)) updated = 0; #Loop throught config for key in config: if(key == param): config[key] = new_value updated = 1; # In case the param doesnt exist yet in the config file if(updated==0): config[param] = new_value logging.debug('The parameter ' + str(param) + ' didnt exist in config.txt') # We rewrite the config file # WARNING: we need to recrypt cam_pwd here as read_config_raw decrypt it file = open("/home/pi/fireball_camera/config.txt", "w") for key in config: value = config[key] if(key=='cam_pwd'): c = Crypt() value = c.encrypt(value) if(key!='error'): line = str(key) + "=" + str(value) + "\n" file.write(line) file.close() else: logging.error('We tried to update cam_pwd with add_to_config: IMPOSSIBLE')
def remove_from_config(param): config = read_config_raw(); i=0 while i < len(param): if(param[i] in config): del config[param[i]] i += 1 file = open("/home/pi/fireball_camera/config.txt", "w") for key in config: value = config[key] if(key=='cam_pwd'): c = Crypt() value = c.encrypt(value) line = str(key) + "=" + str(value) + "\n" file.write(line) file.close()
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:
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
else: logging.debug('cam_pwd does NOT exist in config.txt - we add it') #Update the Cam Password via the cgi fname = 'http://'+config['cam_ip']+'/cgi-bin/pwdgrp_cgi?action=update&user=admin&pwd=admin&username=admin&password='******'Updating the cam_pwd on the camera side:' + fname) # Call to CGI urllib.urlopen(fname) # Encrypt the Cam Password to store it in the config file try: c = Crypt() value = c.encrypt(value) logging.debug('cam_pwd successfully encrypted') # Write new pwd in config.txt line = "cam_pwd=" + str(value) + "\n" file.write(line) except: logging.error('IMPOSSIBLE to encrypted the following cam_pwd ' + str(value)) logging.debug('Config (ERROR) ' + str(config)) del tmp_config['new_cam_pwd'] logging.debug('Updating config.txt') for key in tmp_config: value = tmp_config[key]
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'])
class TransactionFactory(object): def __init__(self, config, mongo, block_height, bulletin_secret='', username='', value=0, fee=0.0, requester_rid='', requested_rid='', public_key='', dh_public_key='', private_key='', dh_private_key='', to='', inputs='', outputs='', coinbase=False, chattext=None, signin=None): self.config = config self.mongo = mongo self.block_height = block_height self.bulletin_secret = bulletin_secret self.username = username self.requester_rid = requester_rid self.requested_rid = requested_rid self.public_key = public_key self.dh_public_key = dh_public_key self.private_key = private_key self.value = value self.fee = float(fee) self.dh_private_key = dh_private_key self.to = to self.time = str(int(time.time())) self.outputs = [] for x in outputs: self.outputs.append(Output.from_dict(x)) self.inputs = [] for x in inputs: if 'signature' in x: self.inputs.append( ExternalInput.from_dict(self.config, self.mongo, x)) else: self.inputs.append(Input.from_dict(x)) self.coinbase = coinbase self.chattext = chattext self.signin = signin self.do_money() inputs_concat = self.get_input_hashes() outputs_concat = self.get_output_hashes() if bulletin_secret: self.rid = self.generate_rid() if self.chattext: self.relationship = json.dumps({"chatText": self.chattext}) self.cipher = Crypt(self.config.wif) self.encrypted_relationship = self.cipher.encrypt( self.relationship) elif self.signin: for shared_secret in TU.get_shared_secrets_by_rid( self.config, self.mongo, self.rid): self.relationship = SignIn(self.signin) self.cipher = Crypt(shared_secret.encode('hex'), shared=True) self.encrypted_relationship = self.cipher.shared_encrypt( self.relationship.to_json()) else: if not self.dh_public_key or not self.dh_private_key: a = os.urandom(32) self.dh_public_key = scalarmult_base(a).encode('hex') self.dh_private_key = a.encode('hex') self.relationship = self.generate_relationship() if not private_key: raise BaseException('missing private key') self.cipher = Crypt(self.config.wif) self.encrypted_relationship = self.cipher.encrypt( self.relationship.to_json()) else: self.rid = '' self.encrypted_relationship = '' self.header = (self.public_key + self.time + self.dh_public_key + self.rid + self.encrypted_relationship + "{0:.8f}".format(self.fee) + self.requester_rid + self.requested_rid + inputs_concat + outputs_concat) self.hash = hashlib.sha256(self.header).digest().encode('hex') if self.private_key: self.transaction_signature = TU.generate_signature_with_private_key( private_key, self.hash) else: self.transaction_signature = '' self.transaction = self.generate_transaction() def do_money(self): my_address = str( P2PKHBitcoinAddress.from_pubkey(self.public_key.decode('hex'))) input_txns = BU.get_wallet_unspent_transactions( self.config, self.mongo, my_address) miner_transactions = self.mongo.db.miner_transactions.find() mtxn_ids = [] for mtxn in miner_transactions: for mtxninput in mtxn['inputs']: mtxn_ids.append(mtxninput['id']) if self.inputs: inputs = self.inputs else: inputs = [] for input_txn in input_txns: if input_txn['id'] not in mtxn_ids: if 'signature' in input_txn: inputs.append( ExternalInput.from_dict(self.config, self.mongo, input_txn)) else: inputs.append(Input.from_dict(input_txn)) input_sum = 0 if self.coinbase: self.inputs = [] else: if inputs: needed_inputs = [] done = False for y in inputs: print y.id txn = BU.get_transaction_by_id(self.config, self.mongo, y.id, instance=True) if isinstance(y, ExternalInput): y.verify() address = str( P2PKHBitcoinAddress.from_pubkey( txn.public_key.decode('hex'))) else: address = my_address for txn_output in txn.outputs: if txn_output.to == address: input_sum += txn_output.value needed_inputs.append(y) if input_sum >= ( sum([x.value for x in self.outputs]) + self.fee): done = True break if done == True: break if not done: raise NotEnoughMoneyException('not enough money') self.inputs = needed_inputs else: self.inputs = [] remainder = input_sum - (sum([x.value for x in self.outputs]) + self.fee) found = False for x in self.outputs: if my_address == x.to: found = True x.value += remainder if not found: return_change_output = Output(to=my_address, value=remainder) self.outputs.append(return_change_output) def get_input_hashes(self): from fastgraph import FastGraph input_hashes = [] for x in self.inputs: txn = BU.get_transaction_by_id(self.config, self.mongo, x.id, instance=True, include_fastgraph=isinstance( self, FastGraph)) input_hashes.append(str(txn.transaction_signature)) return ''.join(sorted(input_hashes, key=str.lower)) def get_output_hashes(self): outputs_sorted = sorted([x.to_dict() for x in self.outputs], key=lambda x: x['to'].lower()) return ''.join( [x['to'] + "{0:.8f}".format(x['value']) for x in outputs_sorted]) def generate_rid(self): my_bulletin_secret = self.config.get_bulletin_secret() if my_bulletin_secret == self.bulletin_secret: raise BaseException( 'bulletin secrets are identical. do you love yourself so much that you want a relationship on the blockchain?' ) bulletin_secrets = sorted( [str(my_bulletin_secret), str(self.bulletin_secret)], key=str.lower) return hashlib.sha256( str(bulletin_secrets[0]) + str(bulletin_secrets[1])).digest().encode('hex') def generate_relationship(self): return Relationship( dh_private_key=self.dh_private_key, their_bulletin_secret=self.bulletin_secret, their_username=self.username, my_bulletin_secret=self.config.get_bulletin_secret(), my_username=self.config.username) def generate_transaction(self): return Transaction(self.config, self.mongo, self.block_height, self.time, self.rid, self.transaction_signature, self.encrypted_relationship, self.public_key, self.dh_public_key, float(self.fee), self.requester_rid, self.requested_rid, self.hash, inputs=[x.to_dict() for x in self.inputs], outputs=[x.to_dict() for x in self.outputs], coinbase=self.coinbase) def generate_transaction_signature(self): return TU.generate_signature(self.hash, self.private_key)
# Parse command from standard input try: reply = sys.stdin.readline() except: pass if reply == 'exit\n': return # Set sequence number and identifier icmp.set_icmp_id(icmp_id) icmp.set_icmp_seq(seq_id) # Include the command as data inside the ICMP packet reply = reply.encode('utf8') data = encryptor.encrypt(reply) icmp.contains(ImpactPacket.Data(data)) # Calculate its checksum icmp.set_icmp_cksum(0) icmp.auto_checksum = 1 # Have the IP packet contain the ICMP packet (along with its payload) ip.set_ip_src(client) ip.set_ip_dst(server) ip.contains(icmp) # Send it to the target host sock.sendto(ip.get_packet(), (server, 0)) if __name__ == '__main__':
class TransactionFactory(object): def __init__(self, bulletin_secret='', username='', value=0, fee=0.0, requester_rid='', requested_rid='', public_key='', dh_public_key='', private_key='', dh_private_key='', to='', inputs='', outputs='', coinbase=False, chattext=None, signin=None): self.bulletin_secret = bulletin_secret self.username = username self.requester_rid = requester_rid self.requested_rid = requested_rid self.public_key = public_key self.dh_public_key = dh_public_key self.private_key = private_key self.value = value self.fee = float(fee) self.dh_private_key = dh_private_key self.to = to self.outputs = outputs or [] self.inputs = inputs self.coinbase = coinbase self.chattext = chattext self.signin = signin self.do_money() inputs_concat = self.get_input_hashes() outputs_concat = self.get_output_hashes() if bulletin_secret: self.rid = self.generate_rid() if self.chattext: self.relationship = json.dumps({"chatText": self.chattext}) elif self.signin: for shared_secret in TU.get_shared_secrets_by_rid(self.rid): self.relationship = SignIn(self.signin) self.cipher = Crypt(shared_secret.encode('hex'), shared=True) self.encrypted_relationship = self.cipher.shared_encrypt( self.relationship.to_json()) else: self.relationship = self.generate_relationship() if not private_key: raise BaseException('missing private key') self.cipher = Crypt(Config.wif) self.encrypted_relationship = self.cipher.encrypt( self.relationship.to_json()) else: self.rid = '' self.encrypted_relationship = '' self.hash = hashlib.sha256(self.dh_public_key + self.rid + self.encrypted_relationship + "{0:.8f}".format(self.fee) + self.requester_rid + self.requested_rid + inputs_concat + outputs_concat).digest().encode('hex') self.transaction_signature = self.generate_transaction_signature() self.transaction = self.generate_transaction() def do_money(self): Mongo.init() my_address = str( P2PKHBitcoinAddress.from_pubkey(self.public_key.decode('hex'))) input_txns = BU.get_wallet_unspent_transactions(my_address) miner_transactions = Mongo.db.miner_transactions.find() mtxn_ids = [] for mtxn in miner_transactions: for mtxninput in mtxn['inputs']: mtxn_ids.append(mtxninput['id']) inputs = [ Input.from_dict(input_txn) for input_txn in input_txns if input_txn['id'] not in mtxn_ids ] input_sum = 0 if self.coinbase: self.inputs = [] else: needed_inputs = [] done = False for y in inputs: print y.id txn = BU.get_transaction_by_id(y.id, instance=True) for txn_output in txn.outputs: if txn_output.to == my_address: input_sum += txn_output.value needed_inputs.append(y) if input_sum >= (sum([x.value for x in self.outputs]) + self.fee): done = True break if done == True: break if not done: raise NotEnoughMoneyException('not enough money') self.inputs = needed_inputs return_change_output = Output( to=my_address, value=input_sum - (sum([x.value for x in self.outputs]) + self.fee)) self.outputs.append(return_change_output) def get_input_hashes(self): input_hashes = [] for x in self.inputs: txn = BU.get_transaction_by_id(x.id, instance=True) input_hashes.append(str(txn.transaction_signature)) return ''.join(sorted(input_hashes, key=str.lower)) def get_output_hashes(self): outputs_sorted = sorted([x.to_dict() for x in self.outputs], key=lambda x: x['to'].lower()) return ''.join( [x['to'] + "{0:.8f}".format(x['value']) for x in outputs_sorted]) def generate_rid(self): my_bulletin_secret = Config.get_bulletin_secret() if my_bulletin_secret == self.bulletin_secret: raise BaseException( 'bulletin secrets are identical. do you love yourself so much that you want a relationship on the blockchain?' ) bulletin_secrets = sorted( [str(my_bulletin_secret), str(self.bulletin_secret)], key=str.lower) return hashlib.sha256( str(bulletin_secrets[0]) + str(bulletin_secrets[1])).digest().encode('hex') def generate_relationship(self): return Relationship(dh_private_key=self.dh_private_key, their_bulletin_secret=self.bulletin_secret, their_username=self.username, my_bulletin_secret=Config.get_bulletin_secret(), my_username=Config.username) def generate_transaction(self): return Transaction(self.rid, self.transaction_signature, self.encrypted_relationship, self.public_key, self.dh_public_key, float(self.fee), self.requester_rid, self.requested_rid, self.hash, inputs=self.inputs, outputs=self.outputs, coinbase=self.coinbase) def generate_transaction_signature(self): return TU.generate_signature(self.hash)
def test_encrypt(self): c = Crypt(self.cipher_key) encrypted = c.encrypt('some random plain text') assert encrypted == 'b1XdLeAJ54bz/ALcDd2FeAez7y5z33Le'
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])
from crypt import Crypt c = Crypt() a = c.encrypt('12345') print(a) b = c.decrypt(a) print(b)