def op1(): key = enc.getKey() if key != b'': enc.decrypt() print("Done.") else: print("Files are already decrypted. Enjoy!")
def manager(): decrypt("Hotel.db") output = Manager.query.all() log.dbSelect(app.config['SQLALCHEMY_DATABASE_URI'],"Manager",Guest.query.count()) db.session.close() encrypt("Hotel.db") return render_template('show(man).html',out=output, currentID = currentID)
def load_user(id): print("FILE DECRYPTED_________________2") decrypt("Hotel.db") out = int(id) db.session.close() encrypt("Hotel.db") return out
def breathe(sock, packet, host): sock.sendto(packet, (host, 3848)) upnet_ret = sock.recv(3848) upnet_ret = [i for i in struct.unpack('B' * len(upnet_ret), upnet_ret)] encrypt.decrypt(upnet_ret) status2 = upnet_ret[20] return status2
def destagano_file(self): key = self.key.get() print(key) if self.file != -1: if self.file.endswith(".zip"): with ZipFile(self.file, 'r') as zip: zip.printdir() dir = tempfile.gettempdir() extract_dir = dir + "\\GUI\\extracted_images\\" + Path( self.file).name[0:-4] #process_dir = dir + "\\GUI\\processed_images\\" + Path(self.file).name[0:-4] print(extract_dir) zip.extractall(extract_dir) # if not os.path.exists(process_dir): # os.makedirs(process_dir) listfiles = os.listdir(extract_dir) for file in listfiles: msg = decode_image(extract_dir + "\\" + file) print(msg) print("decrypted message : " + decrypt(msg.encode('utf-8'), key, salt, nonce)) messagebox.showinfo( file, "decrypted message : " + decrypt(msg.encode('utf-8'), key, salt, nonce)) # processedfiles = os.listdir(process_dir) # for file in processedfiles: # ocr_text = ocr_core(process_dir+"\\"+file) # print(ocr_text) print("done")
def lembrar(): endereco = input( "\nInsira o endereço/site do qual você deseja lembrar as informações (Ex: email, facebook) ou \"sair\" sem as aspas para sair" ) if endereco == 'sair': return banco = carregar_json() try: dados = banco[endereco] except: print("\nEssa entrada não existe") i = 0 senha_escondida = '' while i < len(decrypt(dados[1])): senha_escondida = senha_escondida + '*' i += 1 print("\n" + endereco + "\n" + dados[0] + "\n" + senha_escondida + "\n") x = input("\nDeseja receber essas informações?(S/N) ") if x == 's' or x == 'S': print("\n" + endereco + "\n" + dados[0] + "\n" + decrypt(dados[1]) + "\n")
def room(): decrypt("Hotel.db") output = Room.query.all() log.dbSelect(app.config['SQLALCHEMY_DATABASE_URI'],"Room",Room.query.count()) db.session.close() encrypt("Hotel.db") return render_template('show(room).html',out=output)
def run(self): global clientsent msg = self.sock.recv(BUFFER_SIZE) rsize = 0 fsize = int(msg.decode("ascii").strip()) print("fsize: " + str(fsize)) b = 0 threadLock.acquire() filen = 'model_' + str(self.n) + '.h5' with open(filen, 'wb') as f: print('file opened') while rsize < fsize: b += 1 data = self.sock.recv(BUFFER_SIZE) # print('data=%s', (data) ) # print('rsize' + str(rsize)) if not data or data == 'END': self.sock.close() print('file close()') break elif rsize >= fsize: f.close() break else: f.write(data) # print("writing " + str(b)) rsize = rsize + len(data) # print("------------") f.close() print('Successfully received file from client: ' + str(self.n)) encrypt.decrypt(filen) clientsent += 1 threadLock.release() l = evnt.wait() filename = 'modelf_e.h5' f = open(filename, 'rb') while True: print("sending") l = f.read(BUFFER_SIZE) while (l): self.sock.send(l) #print('Sent ',repr(l)) l = f.read(BUFFER_SIZE) if not l: f.close() self.sock.close() break print('Successfully sent file to client: ' + str(self.n))
def op3(): key = enc.getKey() if key == b'': print("The key is " + str(enc.createNewKey())) enc.encrypt() else: enc.decrypt() print("The key is " + str(enc.createNewKey())) enc.encrypt() print("Done.")
def register(): letterloop = 0 logdigit = 0 loglower = 0 logupper = 0 logsymbol = 0 RegisterUser = RegisterUserForm(request.form) #make sure to clear and check fields are ok before inserting into sql database with open('./BannedPasswords/banned-passwords-1.txt', 'r') as BannedPassList: found = False if request.method == 'POST' and RegisterUser.validate(): for line in BannedPassList: if str(RegisterUser.password.data) in line: print("This password is not allowed") return 'This password is not allowed' if not found: logpass = str(RegisterUser.password.data) while letterloop < len(logpass): if logpass[letterloop].isdigit(): logdigit += 1 elif logpass[letterloop].islower(): loglower += 1 elif logpass[letterloop].isupper(): logupper += 1 else: logsymbol += 1 letterloop += 1 if logdigit >= 1 and loglower >= 1 and logupper >= 1 and logsymbol >= 1 and len(logpass) >= 8: logpass = pbkdf2_sha256.hash(logpass) user = Guest(g_name=RegisterUser.name.data, g_email=RegisterUser.email.data, g_password=logpass, g_credit_card=RegisterUser.cc.data, g_phone=RegisterUser.num.data) decrypt("Hotel.db") db.session.add(user) log.dbInsert(app.config['SQLALCHEMY_DATABASE_URI'],"Guest",RegisterUser.email.data, RegisterUser.name.data, str(RegisterUser.cc.data)[-4:0], "1") db.session.commit() log.dbCommit(app.config['SQLALCHEMY_DATABASE_URI'],"Guest","1") try: log.reg_new(RegisterUser.username.data) except Exception: print("Error occurred while logging Registering new guest.") print("Guest successfully registered") session['logged_in'] = 1 session['user'] = RegisterUser.name.data login_user(user) db.session.close() encrypt("Hotel.db") try: log.reg_new(RegisterUser.name.data) except Exception: print("Error occurred while logging Registering new user.") return redirect(url_for('index')) else: return 'Password must contain at least 1 digit, 1 symbol, 1 uppercase character and 1 lowercase character' return render_template('register.html', form=RegisterUser)
def upload_image(path_to_image, poster_name, extension): ts = time.time() encrypt.decrypt('encrypted', os.environ['encryption_key'], 'credentials.json') os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "credentials.json" fb.FirebaseApplication('https://tribe-images.appspot.com') client = storage.Client() bucket = client.get_bucket('tribe-images.appspot.com') # posting to firebase storage image_blob = bucket.blob(poster_name + "/" + poster_name.lower() + str(ts) + extension) image_blob.upload_from_filename(path_to_image) image_blob.make_public() return image_blob.public_url
def new_Man(): if session['logged_in'] == 1: man = new_man(request.form) #make sure to clear and check fields are ok before inserting into sql database if request.method == 'POST': decrypt("Hotel.db") NewMan = Manager(m_id=int(session['_user_id']),m_name=man.name.data,m_salary=man.salary.data,m_age=man.age.data,m_gender=man.gender.data,m_department=man.department.data,password=man.password.data) db.session.add(NewMan) db.session.commit() db.session.close() encrypt("Hotel.db") return redirect(url_for('manager')) return render_template('new_man.html', form=man) else: return redirect(url_for('index'))
def run(usr): while (0 == 0): web_interface.get_file(usr) encrypt.decrypt(["mati2000", "koniec"]) msg = input() encrypt.encrypt(msg, ["mati2000", "koniec"]) web_interface.upload_file(usr % 1) print("would you like to send another file (y/n)") response = input() if (response == "n"): break
def upnet(sock, packet, host, getsession): sock.sendto(packet, (host, 3848)) upnet_ret = sock.recv(3848) upnet_ret = [i for i in struct.unpack('B' * len(upnet_ret), upnet_ret)] encrypt.decrypt(upnet_ret) status2 = upnet_ret[20] session_len = upnet_ret[22] session = upnet_ret[23:session_len + 23] message_len = upnet_ret[upnet_ret.index(11, 35) + 1] message = upnet_ret[upnet_ret.index(11, 35) + 2:message_len + upnet_ret.index(11, 35) + 2] message = ''.join([struct.pack('B', i) for i in message]).decode('gbk') for i in session: getsession.append(i) return status2, message
def keyring(deployment, keyring_file='~/.nrg-keyring.enc', passphrase=None): ''' Get keyring for deployment :param deployment: Deployment name :type deployment: str :param keyring_file: Keyring file :type keyring_file: str :param passphrase: Passphrase to decrypt keyring :type passphrase: str :returns: Deployment keyring :rtype: dict ''' if deployment == None: return keyring_from_env() if passphrase == None: if 'NRG_KEYRING_PASS' in os.environ: passphrase = os.environ['NRG_KEYRING_PASS'] else: passphrase = gp.getpass('enter keyring passphrase: ') keyring_file = os.path.expanduser(keyring_file) with open(keyring_file, 'rb') as fo: key = enc.key_from_file(fo, passphrase) content = b'' for chunk in enc.decrypt(fo, key): content += chunk try: js = json.loads(content) except ValueError as e: raise KeyringError( 'could not decrypt file {0} (wrong passphrase perhaps?)'.format( keyring_file)) return js[deployment]
def read_file(): game_state = {} data_text, time = encrypt.decrypt() data_file = os.path.join( os.getenv('TMP'), '.save.ini') if os.name == 'nt' else '/tmp/.save.cfg' with open(data_file, 'w') as open_file: open_file.write(data_text) ini_file = inifile.IniFile(data_file) #print(ini_file.to_dict()) keys = ini_file.keys() values = ini_file.values() for key, value in zip(keys, values): if '.' in key: # value is in a category klass, prop = key.split('.') #print(klass, prop) try: game_state[klass] except KeyError: game_state[klass] = {} game_state[klass][prop] = value else: game_state[key] = value return game_state
def import_record(record, public_key, private_key): """ Import an encrypted and signed BSON record public_key is the sender's public key private_key is the recipient's private key (i'm the recipient) """ try: final = bson.BSON.decode(base64.b64decode(record)) ret_bin = final['key'] ret_bin = rsa.decrypt_rsa(ret_bin, private_key) key = ret_bin[:32] iv = ret_bin[32:32+12] tag = ret_bin[32+12: 32+12+16] final_record_bson = encrypt.decrypt(key, iv, tag, final['record']) final_record = bson.BSON.decode(final_record_bson) if not rsa.verify_rsa(final_record["record"], final_record["signature"], public_key): print("Signature not match") raise Exception('signature not match') record = bson.BSON.decode(final_record["record"]) return record except: print("Import record failed") raise
def __init__(self, parent): sc.SizedPanel.__init__(self, parent, -1) ftppanel = sc.SizedPanel(self, -1) ftppanel.SetSizerType("form") ftppanel.SetSizerProp("expand", True) self.lblFTPSite = wx.StaticText(ftppanel, -1, _("FTP Site")) self.txtFTPSite = wx.TextCtrl(ftppanel, -1, settings.ProjectSettings["FTPHost"]) self.txtFTPSite.SetSizerProp("expand", True) self.lblUsername = wx.StaticText(ftppanel, -1, _("Username")) self.txtUsername = wx.TextCtrl(ftppanel, -1, settings.ProjectSettings["FTPUser"]) self.txtUsername.SetSizerProp("expand", True) self.lblPassword = wx.StaticText(ftppanel, -1, _("Password")) # FIXME - restore this setting once I clean up the FTP support self.txtPassword = wx.TextCtrl( ftppanel, -1, encrypt.decrypt(settings.ProjectSettings["FTPPassword"]), style=wx.TE_PASSWORD ) self.txtPassword.SetSizerProp("expand", True) self.lblDirectory = wx.StaticText(ftppanel, -1, _("Directory")) self.txtDirectory = wx.TextCtrl(ftppanel, -1, settings.ProjectSettings["FTPDirectory"]) self.txtDirectory.SetSizerProp("expand", True) self.chkPassiveFTP = wx.CheckBox(self, -1, _("Use Passive FTP")) self.chkUploadOnSave = wx.CheckBox(self, -1, _("Upload Files on Save")) self.txtFTPSite.SetFocus() self.txtFTPSite.SetSelection(0, -1)
def guest(): #print(session['_user_id']) try: currentID = session['_user_id'] print("id:",session['_user_id']) print("session",session['logged_in']) except KeyError: currentID = -1 except Exception as E: print("This happened: ",E) decrypt("Hotel.db") output = Guest.query.all() log.dbSelect(app.config['SQLALCHEMY_DATABASE_URI'],"Guest",Guest.query.count()) db.session.close() encrypt("Hotel.db") return render_template('show(guest).html',out=output, currentID = currentID)
def init_decrypt(self): self.get_save_path() self.write_error() ciph_file = self.open_file(self.file_box.get(), "r") if ciph_file: try: contents = [i.strip() for i in ciph_file.split(",")] ck = (int(contents[0]), (int(contents[1]), int(contents[2]))) # temp0 = 0 # temp1 = [] # for i in ciph_file: # temp0 += 1 # if i == ",": # temp1.append(temp0) # c = int(ciph_file[0:temp1[0] - 1]) # d = int(ciph_file[temp1[0]:temp1[1] - 1]) # n = int(ciph_file[temp1[1]:len(ciph_file)]) # ck = (c, (d, n)) encoded_text = decrypt(ck) plain_text = decode(encoded_text) decrypted_save_path = self.save_file_path + self.file_name + "_decrypted.txt" self.write_output(plain_text) self.open_file(decrypted_save_path, "w", plain_text) self.write_error( f"Successfully decrypted to {decrypted_save_path}.") except IndexError: self.write_error("Error: Invalid encrypted file") except ValueError: self.write_error("Error: Invalid encrypted file")
def test_ipfs_integration(user_contract, web3): # create new private key key = encrypt.createKey() # get public key from private key binPubKey1 = key.publickey().exportKey('DER') # set public key for user in blockchain user_contract.transact().setPubKey(binPubKey1) # retrieve public key for user binPubKey2 = user_contract.call().userPubkey(web3.eth.accounts[0]) # import public key from blockchain pubKeyObj = RSA.importKey(binPubKey2) # encrypt message with public key of user enc_data = encrypt.encrypt(pubKeyObj, 'Last Night...') # connect to locally running IPFS daemon api = ipfsapi.connect('127.0.0.1', 5001) # add encrypted message res = api.add_bytes(enc_data) print("\n\nIPFS_HASH_CREATE:\t", res) # filter for YouHaveMail events on contract transfer_filter = user_contract.on("YouHaveMail") user_contract.transact().sendMessage(web3.eth.accounts[1], res) wait(transfer_filter) log_entries = transfer_filter.get() # extract ipfsHash from event res = log_entries[0]['args']['_ipfsHash'] print("IPFS_HASH_EVENT:\t", res) # get stored encrypted message from IPFS ret = api.cat(res) print("IPFS_HASH_DATA:\t\t", ret) # decrypt message with private key of user print("IFPS_DATA_DECR:\t\t", encrypt.decrypt(ret, key))
def decrypt_file(file_path, password): f = open(file_path, 'r') contents = f.read() decrypted = e.decrypt(contents, password) f.close() f = open(file_path, 'w') f.write(decrypted) f.close
def decrypt_data(user_password, salt, iv, tag, data): """ Decrypt the data in form of [IV,TAG,CIPHER]. Raise exception when failed to decrypt file. """ key = pyscrypt.hash(password = user_password.encode(encoding='UTF-8'), salt = salt.encode(encoding='UTF-8'), N = 1024, r = 1, p = 1, dkLen = 32) ret = encrypt.decrypt(key, iv, tag, data) return ret
def web_host(): audio("Accessing you web hosting package") browser = webdriver.Chrome("C:\chromedriver.exe") browser.get('https://www.ecowebhosting.co.uk/cp/login') email = browser.find_element_by_id('loginemail') email.send_keys('*****@*****.**') password = browser.find_element_by_id('loginpassword') password.send_keys(decrypt("ubzvu^opka2.B")) browser.find_element_by_class_name('btn-green').click()
def php_myadmin(): audio("Accessing localhost database") browser = webdriver.Chrome("C:\chromedriver.exe") browser.get('http://localhost/phpmyadmin/') username = browser.find_element_by_id('input_username') username.send_keys('root') password = browser.find_element_by_id('input_password') password.send_keys(decrypt('r^upyltaB')) browser.find_element_by_id('input_go').click()
def __init__(self): self.conn = MySQLdb.connect(host='127.0.0.1',user='******',passwd=encrypt.decrypt(120,'BAKBLFFDBCLAJAEBJEKELE'),port=33063) self.cursor = self.conn.cursor(cursorclass = MySQLdb.cursors.DictCursor) self.sql = 'show slave status' self.cursor.execute(self.sql) self.data = self.cursor.fetchall() self.io = self.data[0]['Slave_IO_Running'] self.sql = self.data[0]['Slave_SQL_Running'] self.conn.close()
def recvall(self,n): data = bytearray() while len(data) < n: packet = self.socket.recv(n - len(data)) if not packet: print("not packet") return None data += packet data=decrypt(data) return data
def read_secret(self, filename, password=None): from encrypt import (encrypt, decrypt) with open(f"{filename}.dat", "rb") as fp: fOut = fp.read() secret = decrypt(fOut, password) if secret[:4] == SEED_PREFIX: seed = Seed.from_bytes(secret[4:]) self.import_seed(seed, passphrase=password) elif secret[:4] == XPRV_PREFIX: pass
def images_to_movie(img_urls): print(img_urls) encrypt.decrypt('encrypted', os.environ['encryption_key'], 'credentials.json') os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "credentials.json" fb.FirebaseApplication('https://tribe-images.appspot.com') client = storage.Client() movie_name = 'movie.mp4' extensions = [] for i in range(len(img_urls)): extensions.append(img_urls[i][0][img_urls[i][0].rfind('.'):]) file_name = str(i) + extensions[i] f = open(file_name, 'wb') f.write(requests.get(img_urls[i][0]).content) f.close() slack_api.send_debug_message("Generating Movie", level="INFO") ( ffmpeg.input('./*.jpg', pattern_type='glob', framerate=5).output(movie_name).run() ) return movie_name
def decrypt_msg(content): link = content.split('-')[0] key = content.split('-')[1] cripto_msg = get_msgs()[link] try: msg = decrypt(key, cripto_msg) except UnicodeDecodeError: return 'wrong key', 404 delete_msg(link) return msg
def test_user_public_key(user_contract, web3): key = encrypt.createKey() binPubKey1 = key.publickey().exportKey('DER') print(sys.getsizeof(binPubKey1)) user_contract.transact().setPubKey(binPubKey1) binPubKey2 = user_contract.call().userPubkey(web3.eth.accounts[0]) print(binPubKey2) pubKeyObj = RSA.importKey(binPubKey2) enc_data = encrypt.encrypt(pubKeyObj, 'Hello there!') print(encrypt.decrypt(enc_data, key))
def menu(option): if option == "1": print(encrypt(input("Text to be encrypted: "))) elif option == "2": print(decrypt(input("Text to be decrypted: "))) elif option == "wyjscie" or option == "3": print("Closing") else: print("Bledna operacja!") return option
def rx_packet(self): head = self.recvall(32) if head == None: return None head = decrypt(head) head = head[5:] lengths = [int(s) for s in head.split() if s.isdigit()] #print(lengths) packet_len = lengths[0] head_len = lengths[1] packet = self.recvall(packet_len) if len(packet) != packet_len: print("packet len does not match size", len(packet), packet_len) packet = decrypt(packet) ret = tx_struct() lines = packet[0:head_len].decode("utf-8").split("\n") ret.id = inp_search_token_value(lines, "#id") ret.file_name = inp_search_token_value(lines, "#file_name") ret.size = int(inp_search_token_value(lines, "#size")) ret.target = inp_search_token_value(lines, "#target") ret.zip = int(inp_search_token_value(lines, "#zip")) ret.uzipsize = int(inp_search_token_value(lines, "#uzipsize")) ret.message = inp_search_token_value(lines, "#message") ret.token = inp_search_token_value(lines, "#token") #print(lines) #print(ret.file_name,ret.size,ret.uzipsize,len(data)) if ret.size != 0: ret.data = packet[head_len:head_len + ret.size] if ret.zip == 1: ret.data = zlib.decompress(ret.data) ret.size = len(ret.data) #print(lines,ret.data) return ret
def recvall(self, n): data = bytearray() while len(data) < n: packet = self.socket.recv(n - len(data)) if not packet: print("not packet") return None data += packet #print(100.0*len(data)/n) data = decrypt(data) return data
def sendPostRequest(phoneNo, fname): encrypt.decrypt(dir_path + '/credentials/se') with open(dir_path + '/credentials/se', mode='rb') as f: content = f.read() content = base64.b64decode(content).decode('utf-8') ApiKey = str(content.split()[0]) message = "Birthdays are a new start; fresh beginnings, a time to start new endeavours with new goals. Move forward with fresh confidence and courage. You are a special person, may you have an amazing today and year. Happy birthday " + fname url = "https://www.fast2sms.com/dev/bulk" payload = "sender_id=FSTSMS" + "&message=" + message + "&language=english&route=p&numbers=" + phoneNo headers = { 'authorization': ApiKey, 'Content-Type': "application/x-www-form-urlencoded", 'Cache-Control': "no-cache", } encrypt.encrypt(dir_path + '/credentials/se') return requests.request("POST", url, data=payload, headers=headers)
def __init__(self, parent, directory): FTPUpload.__init__(self, parent, directory) self.isDialog = True sc.SizedDialog.__init__(self, parent, -1, _("Publish to web site"), wx.Point(100,100),wx.Size(400,440), wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER) pane = self.GetContentsPane() self.parent = parent self.makefilelist = True self.mythread = None self.closewindow = False self.filelist = [] self.folderlist = [] self.currentFileNo = 0 self.filesUploaded = 0 self.itemCount = 0 self.projpercent = 0 self.filepercent = 0 self.callback = FTPDialogEventCallback(self) ftpPane = sc.SizedPanel(pane, -1) ftpPane.SetSizerType("form") ftpPane.SetSizerProp("expand", True) self.txtFTPSite = self.AddFormField(ftpPane, _("FTP Site"), settings.ProjectSettings["FTPHost"]) self.txtUsername = self.AddFormField(ftpPane, _("Username"), settings.ProjectSettings["FTPUser"]) self.txtPassword = self.AddFormField(ftpPane, _("Password"), encrypt.decrypt(settings.ProjectSettings["FTPPassword"]), wx.TE_PASSWORD) self.txtDirectory = self.AddFormField(ftpPane, _("Directory"), settings.ProjectSettings["FTPDirectory"]) self.chkPassive = wx.CheckBox(pane, -1, _("Use Passive FTP")) self.fileList = autolist.AutoSizeListCtrl(pane, -1, style=wx.LC_REPORT) self.fileList.SetSizerProps({"expand":True, "proportion":1}) self.fileList.InsertColumn(0, _("File"), width=200) self.fileList.InsertColumn(1, _("Status"), width=200) self.txtTotalProg = wx.StaticText(pane, -1, "Total Progress:") self.projGauge = wx.Gauge(pane, -1, 1, style=wx.GA_PROGRESSBAR) self.projGauge.SetRange(100) self.projGauge.SetSizerProp("expand", True) #self.lstFiles = wxListBox(self, -1, style=wxLB_SINGLE) self.stopupload = False self.btnOK = wx.Button(pane,-1,_("Upload")) self.btnOK.SetSizerProps({"halign":"right", "valign":"center"}) #self.Fit() self.SetMinSize(self.GetSize()) wx.EVT_BUTTON(self.btnOK, self.btnOK.GetId(), self.btnOKClicked) #EVT_TIMER(self, self.mytimer.GetId(), self.OnHang) wx.EVT_CLOSE(self, self.OnClose)
def handle(self): try: data = self.request.recv(1) addr = self.request.recv(ord(data[0])) addr = decrypt(addr) addr_port = struct.unpack("!H", self.request.recv(2))[0] logging.info("Connecting to %s:%s" % (addr, addr_port)) remote = socket.socket(socket.AF_INET, socket.SOCK_STREAM) remote.connect((addr, addr_port)) self.handle_tcp(remote) except socket.error, e: logging.warn(e)
def handle_tcp(self, remote): sock = self.request sock_list = [sock, remote] try: while (1): read_list, _, _ = select(sock_list, [], []) if remote in read_list: data = remote.recv(8192) if (sock.send(decrypt(data)) <= 0): break if sock in read_list: data = sock.recv(8192) if (remote.send(encrypt(data)) <= 0): break finally: remote.close() sock.close()
def parse(self, data): self.buf += data if self.length is None: if len(self.buf) < 8: return self.length, = struct.unpack('<I', self.buf[:4]) if self.buf[4:8] != self.MAGIC: raise socket.error('invalid magic') self.buf = self.buf[8:] if len(self.buf) < self.length: return packet, self.buf = self.buf[:self.length], self.buf[self.length:] self.length = None if self.key: packet = decrypt(packet, self.key) yield packet
def received_block(self, message): """ Handle received block. Args: message (dict): The received message to process. """ client = message['client'] self.logger.debug('received %s block %s of file %s from %s' % (message['block_type'], message['number'], message['name'], client)) # build the new block path file_path = os.path.join('%s', '%s', '%s') % \ (self.temp, client, build_file_name( block_type=message['block_type'], name=message['name'], number=message['number']) ) # if temporary directory doesn't exist, create it if not os.path.exists(self.temp): os.mkdir(self.temp) # if clients' temporary directory doesn't exist, create them for client in self.clients: client_dir = os.path.join(self.temp, client) if not os.path.exists(client_dir): os.mkdir(client_dir) decrypted = encrypt.decrypt(self.key, message['content']) # write the content to file with open(file_path, 'wb') as f: f.write(decrypted)
def __init__(self, parent, rootdir): self.filelist = [] self.dirlist = [] self.rootdir = rootdir self.parent = parent self.isDialog = False isPassive = False if settings.ProjectSettings["FTPPassive"] == "yes": isPassive = True self.ftpService = ftpService( settings.ProjectSettings["FTPHost"], settings.ProjectSettings["FTPUser"], encrypt.decrypt(settings.ProjectSettings["FTPPassword"]), settings.ProjectSettings["FTPDirectory"], isPassive ) self.stopupload = False self.useSearch = 0 self.projpercent = 0 self.filepercent = 0 self.callback = FTPEventCallback() if settings.ProjectSettings["SearchEnabled"] != "": self.useSearch = int(settings.ProjectSettings["SearchEnabled"])
import sys from encrypt import decrypt print decrypt(open(sys.argv[1]).read(), sys.argv[2])
moves = [] for i in range(10000): moves.append(move.Movement(increment, increment)) iterations = range(0, 1000, increment) encrypted_image = numpy.array([x[:] for x in [[0] * 1000] * 1000]) decrypted_image = numpy.array([x[:] for x in [[0] * 1000] * 1000]) for X in iterations: for Y in iterations: cube = rubiks.Cube(list(img[X:X + increment, Y:Y + increment])) encrypt.encrypt(cube, moves) encrypted_image[X:X + increment, Y:Y + increment] = cube.matrix encrypt.decrypt(cube, moves) decrypted_image[X:X + increment, Y:Y + increment] = cube.matrix img = img.astype(numpy.uint16) encrypted_image = encrypted_image.astype(numpy.uint16) decrypted_image = decrypted_image.astype(numpy.uint16) # Assert that the dimensions of original and decrypted are equal assert img.__len__() == decrypted_image.__len__() assert img.__len__() == decrypted_image[0].__len__() # Assert that each pixel in original and decrypted are the same dimensions = [img.__len__(), img[0].__len__()] for i in range(dimensions[0]): for j in range(dimensions[1]): assert img[i][j] == decrypted_image[i][j]
def try_decrypt(k): for c in range(5): x = decrypt(k, open('ciphertext-{}.bin'.format(c+1)).read()) if x is not None: plaintexts[c] = x print "Got plaintext:", x
def preprocess_value(self, value): if value.startswith('~'): value = encrypt.decrypt(value, SAGPASS) # Mustache substitutions! value = value.replace('{{IP}}', self.remote_addr) return value
pubkeyhex = wallet.get_public_key_hex() pubkey = wallet.get_public_key() addrfrom = P2PKHBitcoinAddress.from_pubkey(pubkey) addrfromhex = P2PKHBitcoinAddress.from_pubkey(pubkeyhex.decode("hex")) print("\nAddress From %s" % addrfrom) print("\nAddress From Hex %s" % addrfromhex) message = "bitid://localhost:5000/callback?x=30f56bc022dde976&u=1" print("\nClear: %s" % message) encrypted = encrypt.encrypt(wallet.get_public_key(), message) print("\nEncrypted: %s" % encrypted) decrypted = encrypt.decrypt(wallet.get_private_key_wif(), encrypted) print("\nDecrypted: %s" % decrypted) signature = wallet.sign(message) print("\nSignature: %s" % signature) print("\nVerified: %s" % wallet.verify(message, signature)) test1_raw_hex = '3e52050b58e1765ca9abfce576aa0efc27eaa4dd11a4051affabd050e6b92324' test1_private_key_wif = privateKeyToWif(test1_raw_hex) test1_key = CBitcoinSecret(test1_private_key_wif) test1_pub = test1_key.pub test2_private_key_wif = wallet.get_private_key_wif() test2_key = wallet.get_private_key() test2_pub = test2_key.pub