def update_payload(payload_id, enabled=None, jitter=None, interval=None, visible=None, expiration_date=None): payload = Payload.query.get(payload_id) if jitter: payload.Jitter = jitter if interval: payload.BeaconInterval = interval if expiration_date: payload.ExpirationDate = expiration_date expiration_date = payload.ExpirationDate.isoformat() if enabled is not None: payload.Enabled = enabled if visible is not None: payload.Visible = visible message = dict({ "Id": payload_id, "Jitter": payload.Jitter, "BeaconInterval": payload.BeaconInterval, "ExpirationDate": expiration_date, "Enabled": payload.Enabled, "Visible": payload.Visible }) log("payload.py:update_payload", "Sending: {0}".format(message)) rabbit_producer.send_request("UpdatePayload", message) return dict({"Success": True, "Payload": payload_json(payload)})
def add_agent_checkin(agent_name, transport_id=None, source_ip=None, message=None): hmac = None iv = None msg = None if message: decoded_checkin = b64decode(message) checkin_dict = json.loads(decoded_checkin) hmac = checkin_dict["HMAC"] iv = checkin_dict["IV"] msg = checkin_dict["Message"] if not source_ip: source_ip = request.remote_addr if not transport_id: transport_id = 1 checkin = { 'AgentName': agent_name, 'TransportId': transport_id, 'SourceIp': source_ip, 'HMAC': hmac, 'IV': iv, 'Message': msg } log("add_agent_task_response", "publishing?") rabbit_producer.send_request('NewAgentCheckin', checkin) return { 'Success': True, 'Result': checkin }
def new_console_message(agent_id, content): filenames = re.findall("(f2:files/[^\s]+)", content) display = content if len(filenames) > 0: for filename in filenames: name = filename.replace("f2:files/","") log("new_console_message", "getting bytes for file {0}".format(name)) result = get_faction_file_bytes(name) if result['Success']: content = content.replace(filename, result['Message']) else: return dict({ 'Success': False, 'Message': 'Could not find file: {0}'.format(filename) }) console_message = { "AgentId": agent_id, "UserId": current_user.Id, "Content": content, "Display": display } log("add_message", "publishing message: {0}".format(console_message)) rabbit_producer.send_request('NewConsoleMessage', console_message) return console_message
def create_error_message(message, details=None): error_message = dict({ 'Success': False, 'Source': 'API', 'Message': message, 'Details': details }) rabbit_producer.send_request("NewErrorMessage", error_message) return error_message
def update_agent(agent_id, agent_name=None, visible=None): agent = Agent.query.get(agent_id) if agent_name: agent.Name = agent_name if visible is not None: agent.Visible = visible message = dict({ "Id": agent_id, "Name": agent.Name, "Visible": agent.Visible }) log("update_agent", "sending message: {0}".format(message)) rabbit_producer.send_request("UpdateAgent", message) return {"Success": True, "Result": agent_json(agent)}
def update_transport(transport_id, name=None, transport_type=None, guid=None, configuration=None, enabled=None, visible=None): transport = Transport.query.get(transport_id) # Only update what we're given. Probably a better way to do this.. if name is None: name = transport.Name if transport_type is None: transport_type = transport.TransportType if guid is None: guid = transport.Guid if configuration is None: configuration = transport.Configuration if enabled is None: enabled = transport.Enabled if visible is None: visible = transport.Visible publish_message = { "Id": transport.Id, "Name": name, "TransportType": transport_type, "Guid": guid, "Configuration": configuration, "Enabled": enabled, "Visible": visible } message_id = rabbit_producer.send_request("UpdateTransport", publish_message, callback=True) # Wait for our response # TODO: Add actual timeout here. i = 0 while rabbit_consumer.queue[message_id] is None and i < 15: log("transport:new_transport", "Waiting for {0} seconds".format(15 - i)) sleep(1) i += 1 # Return data message = rabbit_consumer.queue[message_id] if message: return json.loads(message) else: log("transport:update_transport", "Timed out.") return create_error_message("Timeout waiting for response from Core while updating transport. Resubmit your request.")
def upload_payload(payload_id, build_token): log("payload:upload_payload", "Got id: {0} with token: {1}".format(str(payload_id), build_token)) payload = Payload.query.get(payload_id) s = URLSafeSerializer(SECRET_KEY) token_value = s.loads(build_token) log("payload:upload_payload", "token value: {0}".format(token_value)) if payload.Filename == None and payload.Name == token_value: log("payload:upload_payload", "filename is null and token matches") payload.Built = True file = request.files['file'] payload.Filename = secure_filename(file.filename) log("payload:upload_payload", "filename set to: {0}".format(payload.Filename)) try: savePath = os.path.join(payload_upload_dir, payload.Filename) log("payload:upload_payload", "saving file to: {0}".format(savePath)) file.save(savePath) db.session.add(payload) db.session.commit() payload_message = dict({ "Success": True, "Payload": payload_json(payload) }) rabbit_producer.send_request('PayloadUpdated', payload_message) return dict({ 'Success': True, 'Message': 'File saved as {0}'.format(payload.Filename) }) except Exception as e: log("payload:upload_payload", "file save failed: {0}".format(str(e))) return create_error_message('Failed to save file: {0}'.format(str(e))) else: log("payload:upload_payload", "token check failed or payload already built") return create_error_message('Payload token invalid or payload already built')
def new_staging_message(payload_name, staging_id, transport_id, message, source_ip=None): log( "staging_message:new_staging_message", "Got staging request. PayloadName: {0} ID: {1}".format( payload_name, staging_id)) response = get_staging_response(staging_id) if response['Success']: return response else: decoded_response = b64decode(message) response_dict = json.loads(decoded_response) response_dict["PayloadName"] = payload_name response_dict["TransportId"] = transport_id if source_ip == None: source_ip = request.remote_addr response_dict["SourceIp"] = source_ip log("staging_message:new_staging_message", "Publishing: {0}".format(response_dict)) message_id = rabbit_producer.send_request('NewStagingMessage', response_dict, callback=True) # Wait for our response log("staging_message:new_staging_message", "Waiting for 10 seconds") i = 0 while rabbit_consumer.queue[message_id] is None and i < 10: log("staging_message:new_staging_message", "Waiting for {0} seconds".format(10 - i)) sleep(1) i += 1 # Return data message = rabbit_consumer.queue[message_id] if message: log("staging_message", "Got response from Core: {0}".format(message)) return json.loads(message) else: log("staging_message", "Timed out.") return "ERROR"
def new_transport(name): apiKey = new_api_key('transport', 1, current_user.Id) publish_message = dict({ "Name": name, "ApiKeyId": apiKey["Id"], "UserId": current_user.Id }) log("transport:new_transport", "Publishing: {0}".format(publish_message)) message_id = rabbit_producer.send_request("NewTransport", publish_message, callback=True) # Wait for our response # TODO: Add actual timeout here. i = 0 while i < 20: log("transport:new_transport", "Waiting for {0} seconds".format(20 - i)) sleep(1) i += 1 # Return data log("transport:new_transport", "queue: {}".format(rabbit_consumer.queue)) message = rabbit_consumer.queue.get(message_id) if message: log("transport:new_transport", "Got response from Core: {0}".format(message)) message_dict = json.loads(message) if 'Transport' in message_dict.keys(): transport = Transport.query.get(message_dict['Transport']['Id']) return { "Success": True, "TransportId": transport.Id, "ApiKey": { "KeyName": apiKey["Name"], "Secret": apiKey["Secret"] }, "Transport": transport_json(transport) } log("transport:new_transport", "Timed out.") return create_error_message( "Timeout waiting for response from Core while creating new transport. Resubmit your request.")
def new_error_message(source, message): error_message = dict({"Source": source, "Message": message}) rabbit_producer.send_request("NewErrorMessage", error_message) return dict({'Success': True, 'ErrorMessage': error_message})
def new_payload(description, agent_type, transport_id, agent_transport_id, operating_system, architecture, version, format, agent_type_configuration, jitter, interval, debug, expiration_date=None): log("payload:new_payload", "Got request") log("payload:new_payload", "Details - Jitter: {0}, Interval: {1}, AgentType: {2}, ExpirationDate: {3}".format(jitter, interval, agent_type, expiration_date)) if expiration_date != None: try: expiration_date = dateparser.parse(expiration_date).isoformat() except: error_message = create_error_message("Could not convert {0} to a DateTime object".format(expiration_date)) return error_message if jitter is None: jitter_float = None else: try: jitter_float = float(jitter) except: error_message = create_error_message("Jitter is in invalid format. Expected 0.0 to 1.0. Got {0}".format(jitter)) return error_message error_at = None expected = None if not isinstance(transport_id, int): error_at = "TransportId" expected = "Expected an Integer." if not isinstance(agent_transport_id, int): error_at = "AgentTransportId" expected = "Expected an Integer." if not isinstance(interval, int): error_at = "BeaconInterval" expected = "Expected an Integer." if jitter_float is not None and 1.0 < jitter_float < 0.0: error_at = "Jitter" expected = "Expected 0.0 to 1.0." if error_at is not None: error_message = create_error_message("Error processing {0}. {1}".format(error_at, expected)) return error_message payload_name = token_urlsafe(8) s = URLSafeSerializer(SECRET_KEY) build_token = s.dumps(payload_name) publish_message = dict({ "Name": payload_name, "Description": description, "BuildToken": build_token, "AgentTypeId": agent_type, "AgentTransportTypeId": agent_transport_id, "TransportId": transport_id, "OperatingSystemId": operating_system, "ArchitectureId": architecture, "VersionId": version, "FormatId": format, "AgentTypeConfigurationId": agent_type_configuration, "Jitter": "{0:0.1f}".format(jitter_float), "BeaconInterval": interval, "ExpirationDate": expiration_date, "Debug": debug }) log("payload:new_payload", "Publishing: {0}".format(publish_message)) message_id = rabbit_producer.send_request("NewPayload", publish_message, callback=True) # Wait for our response # TODO: Add actual timeout here. i = 0 while rabbit_consumer.queue[message_id] is None and i < 15: log("payload:new_payload", "Waiting for {0} seconds".format(15 - i)) sleep(1) i += 1 # Return data message = rabbit_consumer.queue[message_id] if message: log("payload:new_payload", "Got response from Build Server: {0}".format(message)) message_dict = json.loads(message) if message_dict.get('Source'): log("payload:new_payload", "Its an error..") return message_dict else: payload = Payload.query.get(message_dict['Id']) return { "Success": True, "Result": payload_json(payload) } log("payload:new_payload", "Timed out.") return create_error_message("Timeout waiting for response from Core while processing new payload")