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
