def recupererAB():
raw = nc.read_until(b"Possible actions:").decode()
#nc.read()
raw = raw.split("\n")
Ab64 = raw[1][4:]
Bb64 = raw[2][4:]
A = np.reshape(np.frombuffer(decompress(b64d(Ab64)), dtype = np.int64), (280, 280))
B = np.reshape(np.frombuffer(decompress(b64d(Bb64)), dtype = np.int64), (280, 4))
return A, B
def password_decrypt(self, token: bytes) -> Optional[bytes]:
""" Derive the key from the passphrase, then use to decrypt the message. """
salt, iterations_b, token = token.split(b'~')
salt = b64d(salt)
iterations = int.from_bytes(b64d(iterations_b), 'big')
key = self.derive_key(salt, iterations)
try:
return Fernet(key).decrypt(token)
except (InvalidToken, TypeError):
return None
def _default_ClientProof(self):
""" Computes the ClientProof from the AuthInfo """
info = self.AuthInfo
proofs = auth.generate_proofs(self.KeySize,
b64d(auth.read_armored(info.Modulus)),
self.HashedPassword,
b64d(info.ServerEphemeral))
self.ClientEphemeral = proofs['client_ephemeral']
self.ExpectedServerProof = proofs['server_proof']
return proofs['client_proof']
def test_init(self):
"""
`init` function should populate config with a 256 bit key
that is randomly generated
"""
self.assertEqual(len(b64d(self.config['aes_key'])), 256 / 8)
keya = b64d(self.config['aes_key'])
config = {}
crypto.init(config)
self.assertEqual(len(b64d(config['aes_key'])), 256 / 8)
keyb = b64d(config['aes_key'])
self.assertNotEqual(keya, keyb)
def login2():
name = request.form['username']
p2 = request.form['server_secret']
sig = request.form['signature']
server_secret = auth.decrypt(b64d(p2))
genuine = auth.verify(key_for(name), server_secret, b64d(sig))
if genuine:
session['username'] = name
app.logger.info("%s successfully logged in" % (name,))
return "Success"
else:
abort(401)
def final_round(s, seed):
receive_until_match(s, "bob number")
send(s, b64e(b'\x00'))
receive_until_match(s, "bob number")
bob_no = int(receive_until(s, "\n").strip())
alice = DiffieHellman(long_to_bytes(int(seed, 2)))
alice.set_other(bob_no)
print('Shared:', alice.shared)
iv = b64d(receive_until(s, "\n"))
cipher = AES.new(long_to_bytes(alice.shared, 16)[:16], AES.MODE_CBC, IV=iv)
enc_flag = b64d(receive_until(s, "\n"))
print(cipher.decrypt(enc_flag))
def final_round(s, seed, target_seed):
while True:
receive_until_match(s, 'bit-flip str')
receive_until(s, "\n")
send(s, b64e(long_to_bytes(int(seed, 2) ^ target_seed)))
receive_until(s, "\n") # generated after
iv = b64d(receive_until(s, "\n"))
enc_flag = b64d(receive_until(s, "\n"))
for key in range(8):
cipher = AES.new(long_to_bytes(key, 16)[:16], AES.MODE_CBC, IV=iv)
flag = cipher.decrypt(enc_flag)
if 'DrgnS' in flag:
print(flag)
return
def authenticate_message(form):
keyB = auth.decrypt(b64d(form['key']))
payload = b64d(form['payload'])
payload = auth.aes_decrypt(payload, keyB)
payload = json.loads(payload)
sender, recipient, body, keyA, sig, keyA2 = payload['sender'], payload['recipient'], payload['body'], payload['key'], payload['signature'], payload['sender_key']
sender_user = db.get_user(sender)
recipient_user = db.get_user(recipient)
if not (sender_user and recipient_user):
return (False,)
sig = b64d(sig)
if auth.verify(key_for(sender), sender+recipient+body, sig):
return (True, (sender, recipient, body, keyA, keyA2))
else:
return (False,())
def __load_key(self, file_name):
try:
with open(f"{file_name}.key", "r") as signature_file:
key = b64d(signature_file.read())
return key
except FileNotFoundError as e:
print(f">>> File {file_name} not found")
def decrypt(self, ctext: str, password: str) -> str:
ctext = ctext.encode()
decoded = b64d(ctext)
salt, iter, ctext = decoded[:16], decoded[16:20], b64e(decoded[20:])
iterations = int.from_bytes(iter, "big")
key = self._derive_key(password.encode(), salt, iterations)
return Fernet(key).decrypt(ctext).decode()
def password_decrypt(token: str, password: str) -> str:
token = token.encode()
decoded = b64d(token)
salt, iter, token = decoded[:16], decoded[16:20], b64e(decoded[20:])
iterations = int.from_bytes(iter, 'big')
key = _derive_key(password.encode(), salt, iterations)
return Fernet(key).decrypt(token).decode()
def decrypt_message(crypted_data, passphrase):
"""Decrypt secret with passphrase."""
decoded = b64d(crypted_data)
salt, iter, crypted_data = decoded[:16], decoded[16:20], b64e(decoded[20:])
iterations = int.from_bytes(iter, 'big')
key = _derive_key(passphrase.encode(), salt, iterations)
return Fernet(key).decrypt(crypted_data).decode('utf-8')
def decrypt(cls, value):
from django.conf import settings
decoded = b64d(value.encode())
salt, encrypted_value = decoded[:16], b64e(decoded[16:])
key = cls.get_key(force_bytes(settings.SECRET_KEY), salt)
return Fernet(key).decrypt(encrypted_value).decode()
def encrypt(cls, value):
from django.conf import settings
salt = secrets.token_bytes(16)
key = cls.get_key(force_bytes(settings.SECRET_KEY), salt)
encrypted_value = b64d(Fernet(key).encrypt(value.encode()))
return b64e(b"%b%b" % (salt, encrypted_value)).decode()
def decrypt_value(secret: str, encrypted_value: str) -> str:
decoded = b64d(encrypted_value)
salt, iter, token = decoded[:16], decoded[16:20], b64e(decoded[20:])
iterations = int.from_bytes(iter, 'big')
key = PasswordsEncryption._derive_key(secret.encode(), salt)
initial_data = Fernet(key).decrypt(token)
return initial_data.decode()
def decode(proxy):
splitted = proxy.split(':')
splitted[0] = re.search(r'"(.+)"', splitted[0])[0]
splitted[0] = b64d(splitted[0]).decode()
return '@' + ':'.join(splitted)
def unobscure(obscured: bytes) -> bytes:
"""
Unobscure obscured data bytes to readable bytes
:param obscured: Obscured data bytes
:return: Readable data bytes
"""
return decompress(b64d(obscured))
def password_encrypt(message: bytes,
password: str,
iterations: int = iterations) -> bytes:
salt = secrets.token_bytes(16)
key = _derive_key(password.encode(), salt, iterations)
return b64e(b'%b%b%b' % (salt, iterations.to_bytes(
4, 'big'), b64d(Fernet(key).encrypt(message))))
def __load_signature_from_file(self, file_name):
try:
with open(f"{file_name}.sig", "r") as signature_file:
signature = b64d(signature_file.read())
return signature
except FileNotFoundError as e:
print(f">>> File {file_name} not found\n")
def read_key_from_file():
""" Read saved HMACing key """
try:
with open(KEY_FILE, 'rb') as key_file:
return b64d(key_file.read())
except:
logging.warning("error reading from key file")
def pwd_encrypt(message: (str, bytes), pwd: str, i: int = 100_000) -> bytes:
message = message if isinstance(message,
bytes) else message.encode('utf-8')
zout = secrets.token_bytes(16)
key = __derive_key(pwd.encode(), zout, i)
return b64e(
b'%b%b%b' %
(zout, i.to_bytes(4, 'big'), b64d(Fernet(key).encrypt(message))))
def decrypt(self, encrypted_message, private_key_file):
private_key = self.__load_private_key_from_file(private_key_file)
decrypt = private_key.decrypt(
b64d(encrypted_message.encode()),
padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None))
return decrypt.decode()
def encrypt_config(config, config_data):
enc_config = {
'aes_key': config['passphrase_aes_key'],
'sha256hmac_key': config['passphrase_sha256hmac_key'],
'crypto': config['crypto']
}
return b64d(config['passphrase_salt']) + encrypt_then_mac(
enc_config, config_data)
def encrypt_message(message, passphrase, iterations=100_000):
"""Encrypt secret with passphrase."""
salt = secrets.token_bytes(16)
key = _derive_key(passphrase.encode(), salt, iterations)
return b64e(b'%b%b%b' % (
salt,
iterations.to_bytes(4, 'big'),
b64d(Fernet(key).encrypt(message)),
))
def getencryptedflag():
print(conn.recvuntil(b'> ').decode())
print('1')
conn.sendline(b'1')
print(conn.recvuntil(b'thinking: ').decode())
flag_ct = conn.recvuntil(b'\r\n').strip()
print(flag_ct)
flag_ct = b64d(flag_ct)
return flag_ct
def value_encrypt(message: bytes, password: str, iterations: int) -> bytes:
salt = os.urandom(16)
key = _derive_key(password.encode(), salt, iterations)
print("Key is: %s" % (key, ))
return b64e(b'%b%b%b' % (
salt,
iterations.to_bytes(4, 'big'),
b64d(Fernet(key).encrypt(message)),
))
def password_decrypt(self, token: bytes, password: str) -> bytes:
decoded = b64d(token)
salt, iter, token = decoded[:16], decoded[16:20], b64e(decoded[20:])
iterations = int.from_bytes(iter, 'big')
key = self._derive_key(password.encode(), salt, iterations)
try:
data = Fernet(key).decrypt(token)
except InvalidToken as e:
return None
return Fernet(key).decrypt(token)
def getlocation():
cookie = request.cookies.get('location')
if not cookie:
return ''
(digest, location) = cookie.split("!")
if not safe_str_cmp(calc_digest(location, cookie_secret), digest):
flash("Hey! This is not a valid cookie! Leave me alone.")
return False
location = loads(b64d(location))
return location
def aes_encrypt(config, plaintext):
plaintext = pack('<Q', len(plaintext)) + plaintext
needed_padding = 256 - (len(plaintext) % 256)
if needed_padding == 256:
needed_padding = 0
plaintext = plaintext + (b' ' * needed_padding)
iv = Random.new().read(AES.block_size)
cipher = AES.new(b64d(config['aes_key']), mode=AES.MODE_CBC, IV=iv)
ciphertext = iv + cipher.encrypt(plaintext)
return ciphertext
def aes_decrypt(config, ciphertext):
iv, ciphertext = (ciphertext[:AES.block_size],
ciphertext[AES.block_size:])
cipher = AES.new(b64d(config['aes_key']),
mode=AES.MODE_CBC,
IV=iv)
plaintext = cipher.decrypt(ciphertext)
length, plaintext = (unpack('<Q', plaintext[:8])[0],
plaintext[8:])
return plaintext[:length]
def value_decrypt(byData: bytes, sPassword: str) -> bytes:
byDataDec = b64d(byData)
salt, iter, byData = byDataDec[:16], byDataDec[16:20], b64e(byDataDec[20:])
cIterations = int.from_bytes(iter, 'big')
byKey = key_derive(sPassword, salt, cIterations)
byDecrypted = []
try:
byDecrypted = Fernet(byKey).decrypt(byData)
except:
pass
return byDecrypted
def encrypt(self, text: str, password: str, iterations: int = None) -> str:
if iterations is None:
iterations = self.iterations
assert isinstance(iterations, int)
salt = secrets.token_bytes(16)
key = self._derive_key(password.encode(), salt, iterations)
return b64e(b"%b%b%b" % (
salt,
iterations.to_bytes(4, "big"),
b64d(Fernet(key).encrypt(text.encode())),
)).decode()
def flag_degenerator(flag):
for i in range(11):
try:
flag.decode('zlib')
break
except:
print("Count no: " + str(i))
flag = b64d(flag)
currentFlag = flag.decode('zlib')
print("The flag is: " + currentFlag)
def aes_encrypt(config, plaintext):
plaintext = pack('<Q', len(plaintext)) + plaintext
needed_padding = 256 - (len(plaintext) % 256)
if needed_padding == 256:
needed_padding = 0
plaintext = plaintext + (b' ' * needed_padding)
iv = Random.new().read(AES.block_size)
cipher = AES.new(b64d(config['aes_key']),
mode=AES.MODE_CBC,
IV=iv)
ciphertext = iv + cipher.encrypt(plaintext)
return ciphertext
def api_beacon(target, agent):
logger.info('{}'.format('=' * 50))
data = {'target': target, 'agent': agent}
logger.info('Target: {}'.format(target))
logger.info('Agent: {}'.format(agent))
# check if target is valid
if target not in [x.guid for x in Target.query.all()]:
logger.error('Invalid target GUID.')
abort(404)
# extract universal parameters
comment = b64d(request.values.get('comment', '')).decode() or None
ip = request.environ['REMOTE_ADDR']
if (request.headers.get('X-Real-IP')):
ip = request.headers.get('X-Real-IP')
port = request.environ['REMOTE_PORT']
useragent = request.environ['HTTP_USER_AGENT']
logger.info('Connection from {} @ {}:{} via {}'.format(
target, ip, port, agent))
logger.info('Parameters: {}'.format(request.values.to_dict()))
logger.info('User-Agent: {}'.format(useragent))
logger.info('Comment: {}'.format(comment))
data.update(request.values.to_dict())
data.update({
'comment': comment,
'ip': ip,
'port': port,
'useragent': useragent
})
# process json payloads
if request.json:
if process_json(data, request.json):
abort(404)
# process known coordinates
if all(k in data for k in ('lat', 'lng', 'acc')):
if process_known_coords(data):
abort(404)
# process wireless survey
elif all(k in data for k in ('os', 'data')):
if process_wlan_survey(data):
abort(404)
# process ip geolocation (includes fallback)
process_ip(data)
if re.search('\.(png|jpg|gif)$', data['agent'].lower()):
if os.path.exists(
os.path.join(os.getcwd(),
'server/honeybadger/static/' + data['agent'])):
return send_from_directory(directory='static',
filename=data['agent'],
as_attachment=False,
cache_timeout=0)
else:
abort(404)
abort(404)
def get(self):
uploadRet = str(self.get_argument('upload_ret', ''))
if not uploadRet:
errCode = str(self.get_argument('code', ''))
errDetail = str(self.get_argument('error', 'something error'))
msg = dict()
msg['type'] = 'error'
msg['code'] = errCode
msg['detail'] = urllib.unquote(errDetail)
self.write(json.dumps(msg))
return
msg = b64d(uploadRet)
self.write(msg)
return
def login():
global cookie
resp = post("login", {'username': username})
if resp.status_code != 200:
return False
data = json.loads(resp.text)
client_secret = b64d(data['client_secret'])
secret = auth.decrypt(client_secret)
sig = auth.sign(secret)
resp = post("authorise", {'username': username, 'server_secret': data['server_secret'], 'signature': b64e(str(sig))})
if resp.status_code == 200:
cookie = resp.cookies
return True
return False
def encrypt_config(config, config_data):
enc_config = {'aes_key': config['passphrase_aes_key'],
'sha256hmac_key': config['passphrase_sha256hmac_key'],
'crypto': config['crypto']}
return b64d(config['passphrase_salt']) + encrypt_then_mac(enc_config,
config_data)
def decrypt_message(msg, key): key = auth.decrypt(b64d(key)) return auth.aes_decrypt(b64d(msg), key)
def download(self,sockinfo,httpinfo,args):
proto,host,port,timeout=sockinfo
method,path,httpver,data,headers=httpinfo
requestheaders=headers
httpVer2str=lambda v:'HTTP/%1.1f'%(v/10.0)
httpVer2int=lambda v:int(float(v.split('/')[1])*10)
if '-o' in args:
m=self.init_progress()
if args['-o'].last()=='-':
f=self.console
else:
f=open(args['-o'].last(),'w')
def secondsToStr(t):
rediv = lambda ll,b : list(divmod(ll[0],b)) + ll[1:]
return "%d:%02d:%02d.%03d" % tuple(reduce(rediv,[[t*1000,], 1000,60,60]))
fn=self.protocols[proto][1]
time_start=time.time()
self.if_v('* About to connect() to %s port %d'%(host,port))
connection=fn(host,port)
connection._http_vsn_str=httpVer2str(httpver)
connection._http_vsn=httpver
try:
if proto=='http':arg=[timeout]
else:arg=[]
info=connection.connect(*arg)
ips=[i[4][0] for i in info]
if self.verbose:
for ip in ips:self.if_v('* Trying %s...'%ip)
self.if_v('* Connected to %s (%s) port %d'%(host,ips[-1],port))
except socket.gaierror:
print 'Unable to connect to %s on port %d'%(host,port)
return
time_connect=time.time()
if 'Authorization' in requestheaders:
mode,auth=requestheaders['Authorization'].split(' ')
if mode=='Basic':user=b64d(auth).split(':')[0]
else:user=auth
self.if_v('* Server auth using %s with user %s'%(mode,repr(user)))
connection.putrequest(method,path)
self.if_v('> %s %s %s'%(method,path,httpVer2str(httpver)))
for h,v in requestheaders.iteritems():
connection.putheader(h,v)
self.if_v('> %s: %s'%(h,v))
connection.endheaders()
self.if_v('>')
if data:
connection.send(data)
self.if_v('* upload completely sent off: %d out of %d bytes'%(len(data),len(data)))
time_upload=time.time()
resp=connection.getresponse()
responseheaders=[h.rstrip() for h in resp.msg.headers]
self.if_v('< %s %d %s'%(httpVer2str(resp.version),resp.status,resp.reason))
if self.verbose:
for h in responseheaders:self.if_v('< %s'%h)
self.if_v('<')
buf=resp.read(1024)
out=buf
while buf:
buf=resp.read(1024)
out+=buf
time_download=time.time()
try:totalsize=int(resp.getheader('content-length'))
except:totalsize=len(out)
up_time=time_upload-time_connect
dl_time=time_download-time_upload
if '-o' in args:
try:percentRecieve=(len(out)/float(totalsize))*100
except ZeroDivisionError:percentRecieve=0
try:upSpeed=float(len(data))/up_time/1024.0
except ZeroDivisionError:upSpeed=0
m.update_col(0,'100')
m.update_col(1,'%dk'%(totalsize/1024))
m.update_col(2,'%.1f'%percentRecieve)
m.update_col(3,'%dk '%(len(out)/1024))
m.update_col(4,'%.0fk'%(float(len(out))/dl_time/1024.0))
m.update_col(5,' %.0fk '%upSpeed)
m.update_col(6,secondsToStr(time_download-time_start))
m.finish()
if '-i' in args:
self.console.output('\n'.join(responseheaders)+'\n')
if not '-o' in args:
self.console.output(out+'\n')
else:
f.write(out)
f.close()
connection.close()
if resp.getheader('location') and '-L' in args and self.redirs < self.maxredirs:
self.redirs+=1
nproto,nhost,npath,nquery,nfrag=urlsplit(resp.getheader('location'))
if not nhost:
nhost=host
if not nproto:
nproto=proto
nport=port
if self.protocols[nproto]:
nport=self.protocols[nproto][0]
sockinfo=(nproto,nhost,nport,timeout)
if resp.status in [301, 302, 303]:
nmethod='GET'
else:
nmethod=method
headers={}
if '-e' in args:
spl=args['-e'].last().split(';')
if spl[-1]=='auto':
headers['Referer']=host+path
httpinfo=(nmethod,npath,httpver,None,headers)
self.download(sockinfo,httpinfo,args)
return
if resp.will_close:
state='closed'
else:
state='left intact'
self.if_v('* Connection to host %s %s'%(host,state))
def hmac(config, message):
return HMAC.new(b64d(config['sha256hmac_key']),
message,
SHA256).digest()
from base64 import b64decode as b64d
e = "UDYs1D7bNmdE1o3g5ms1V6RrYCVvODJF1DpxKTxAJ9xuZW=="
k = "flarebearstare"
omap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
nmap = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/"
d = ""
for i, b in enumerate(e):
if b == "=":
d += b
continue
d += omap[nmap.find(e[i])]
print d
key = ""
for i, b in enumerate(b64d(d)):
key += chr(ord(b) - ord(k[i % len(k)]))
print key
def b64_to_hex(b):
return hexlify(b64d(b))
