def main():
""" The entry point of red agent """
listener_port = constant.DEFAULT_LISTENER_PORT
#TODO: Command line arguments should be handled elegantly.
if len(sys.argv) > 1:
listener_port = sys.argv[1]
AttackDB().update()
Listener().work(constant.DEFAULT_LISTENER_IP, int(listener_port))
assumed_state = {
constant.STATE_KEY_PROTOCOL: constant.STATE_VALUE_PROTOCOL_IP,
constant.STATE_KEY_ADDRESS: constant.DEFAULT_TARGET_IP
}
goal = Condition()
goal.add((constant.STATE_KEY_SHELL, constant.CONDITION_OPERATOR_EQUAL,
constant.STATE_VALUE_SHELL_PERMANENT))
goal.add((constant.STATE_KEY_PRIVILEGE, constant.CONDITION_OPERATOR_EQUAL,
constant.STATE_VALUE_PRIVILEGE_ROOT))
planner = Planner(assumed_state, goal)
try:
planner.make_plan()
print(planner)
planner.run()
except Exception as e:
traceback.print_exc()
Listener().stop()
raise e
Listener().stop()
sys.exit(0)
def __run_remote(self, state):
"""
Perform command(private method related to \"run\" method)
This is for executing command on remote machine, which means it will interact with Listener.
:param: state State
:return: Dict state
"""
interface = state["address"]
if self.__get_command_type() == "FILE":
raise RuntimeError("NOT IMPLEMENTED")
if self.__get_recv() == "NONE":
Listener().send_only(interface, self.__get_command(state))
elif self.__get_recv() == "shell":
Listener().send_only(interface, self.__get_command(state))
Listener().update_state_as_address(interface)
state["shell"] = Listener().get_state(interface)
else:
print("command : " + self.__get_command(state))
response = Listener().send(interface, self.__get_command(state))
if response == None:
print("response : None")
else:
if len(response) > 30:
print("response : " + response[:30] + " ...")
else:
print("response : " + response)
if response != None:
state[self.__get_recv()] = response
return state
def start_ip_listener():
listener_ipv4 = None
listener_ipv6 = None
if socket.has_ipv6:
try:
listener_ipv6 = Listener(shared.listening_host,
shared.listening_port,
family=socket.AF_INET6)
listener_ipv6.start()
except Exception as e:
logging.warning(
'Error while starting IPv6 listener on port {}'.format(
shared.listening_port))
logging.warning(e)
try:
listener_ipv4 = Listener(shared.listening_host, shared.listening_port)
listener_ipv4.start()
except Exception as e:
if listener_ipv6:
logging.warning(
'Error while starting IPv4 listener on port {}. '.format(
shared.listening_port) +
'However the IPv6 one seems to be working and will probably accept IPv4 connections.'
)
else:
logging.error(
'Error while starting IPv4 listener on port {}. '.format(
shared.listening_port) +
'You will not receive incoming connections. Please check your port configuration'
)
logging.error(e)
def main():
global EXIT
##join with the tables
hour_subscription=Subscriber()
hour_subscription.subscribe('/topic/enrich/hour', 'join_hour', Listener(hour_subscription,hourly_action))
day_subscription=Subscriber()
day_subscription.subscribe('/topic/report/day', 'join_day', Listener(day_subscription,daily_action))
while not EXIT:
pass
def __init__(self, peer):
# print "A communicator is created!"
self.peer = peer
self.messageQueue = peer.messageQueue
self.mylistener = Listener(peer)
self.mylistener.setDaemon(True)
self.mylistener.start()
def __init__(self):
pyautogui.PAUSE = round(uniform(1.5, 2.3), 2)
self.listener = Listener()
self.search = Search()
self.bglistener = None
self.waypoints = []
self.end = False
def __init__(self):
conn1, conn2 = multiprocessing.Pipe()
self.conn = conn2
self.listener = Listener(debug_connection=conn1)
self.listener.start()
self.bpm_to_test = [0]
self.bpm_energies = [0]
def main():
parser = argparse.ArgumentParser(description='Set configuration.')
parser.add_argument("-c",
"--file",
type=str,
nargs=1,
metavar=('file'),
help="Choose file with URL's list")
parser.add_argument("-l",
"--log",
type=str,
nargs=1,
metavar=('log'),
help="Choose log file")
args = parser.parse_args()
with open(args.file[0]) as file:
data = json.load(file)
dict_list = data['pages']
manager = mp.Manager()
q = manager.Queue()
pool = mp.Pool(mp.cpu_count() + 2)
listener = Listener(q, args.log[0])
for web_page in dict_list:
workers.put(MyTask(web_page, q))
w = pool.apply_async(listener.listener())
def main():
""" Main run function """
set_logging()
logger = logging.getLogger(f"{__name__}.main")
auth = tweepy.OAuthHandler(os.getenv("CONSUMER_KEY"),
os.getenv("CONSUMER_KEY_SECRET"))
auth.set_access_token(os.getenv("ACCESS_TOKEN"),
os.getenv("ACCESS_TOKEN_SECRET"))
api = tweepy.API(auth,
wait_on_rate_limit=True,
wait_on_rate_limit_notify=True)
following = get_following_users(api)
following.extend(get_default_users(api))
tracks = get_following_searches()
logger.info(f"Following {len(following)} users and {len(tracks)} searches")
while True:
listener = Listener()
stream = Stream(auth=api.auth, listener=listener)
try:
logger.info("Started streaming")
stream.filter(follow=following, track=tracks)
except KeyboardInterrupt:
logger.info("Stopped")
break
except ReadTimeoutError as exc:
logger.error("Handled exception:", str(exc), exc_info=True)
finally:
logger.info("Done")
stream.disconnect()
def get_solver(self):
# create empty solver
solver = Solver(Field(self.config['size'], self.config['delta']))
# create parser
parser = BooleanParser()
# get meshgrid
x, y = solver.material['electric'].meshgrid
# create materials
for name, mask, function in self.material['electric']:
solver.material['electric'][parser.parse(str(mask), x=x, y=y)] = \
material_from_string(function, {'epsilon':
Material.epsilon})
for name, mask, function in self.material['magnetic']:
solver.material['magnetic'][parser.parse(str(mask), x=x, y=y)] = \
material_from_string(function, {'mu':
Material.mu})
# create source
for name, mask, function in self.source:
solver.source[parser.parse(str(mask), x=x, y=y)] = \
source_from_string(function)
# create listener
for name, x, y in self.listener:
solver.listener.append(Listener(x, y))
# return new solver
return solver
def chooseNextAction(self):
previous_action = self.current_action
# set next state as the correct action listen, buy, monitor,sell
next_action = Action("null")
if (previous_action.descr == "Listen"):
next_action = Buyer(self.data, previous_action.position, previous_action.log, 0.5)
elif (previous_action.descr =="Buy"):
next_action = Monitor(self.data, previous_action.position, previous_action.log, self.model)
elif (previous_action.descr == "Monitor"):
next_action = Seller(self.data, previous_action.position, previous_action.log, 0.5)
elif (previous_action.descr == "Sell"):
next_action = Listener(self.data, previous_action.position, previous_action.log, self.model)
else:
next_action.descr = "Abort!!!"
self.current_action = next_action
return (next_action)
def __init__(self, ip, binary, name="noname", port=22):
self.name = name
self.ip = ip
self.port = port
listener_port = random.randint(20000, 25000)
self.listener = Listener(name, ip, listener_port, self)
self.binary = Binary(binary, self)
def load_data_tweeter(file_name):
host = locale.MONGODB_SERVER
port = locale.MONGODB_PORT
database = locale.MONGODB_DB
collection = locale.MONGODB_COLLECTION
# OAuth process, using the keys and tokens
auth = OAuthHandler(locale.CONSUMER_KEY, locale.CONSUMER_SECRET)
auth.set_access_token(locale.ACCESS_TOKEN, locale.ACCESS_TOKEN_SECRET)
start_time = time.time()
keyword_list = ['tweets'] # Trank list to search
# Initialize Stream object with a time out limit
twitter_stream = Stream(auth, Listener(start_time, time_limit=3))
# Call the filter method to run the Stream Object
twitter_stream.filter(track=keyword_list, languages=['en'])
with open(file_name, 'r') as json_data:
data = json.load(json_data)
with mongodb_connect(host, port, database, collection) as colection:
colection.delete_many({}) # Cleaning MONGODB collection
data = json.loads(data)
colection.insert(data)
tweets_iterator = colection.find()
for tweet in tweets_iterator:
msg = u'{0} said via twitter: {1}'.format(
tweet['user']['name'], tweet['text'])
print msg
colection.find({"retweeted_status": {"$exists": "true"}})
def __init__(self):
ShowBase.__init__(self)
#Ambient Light
self.init_light()
#backgroundColour seting to mostly red.
self.setBackgroundColor(1, 0.2, 0.2, 1)
#setup scene model and camera position
self.scene = self.init_scene_and_cam()
#some variables:
self.WINDOW_SIZE_X = WINDOW_SIZE_X
self.WINDOW_SIZE_Y = WINDOW_SIZE_Y
self.rodProjectiles = []
self.profProjectiles = []
self.prof_count = 0
self.Profs = []
self.rodney = ''
self.init_profs()
self.init_Rodney()
self.taskMgr.add(self.collision_task, "handle_collisions")
Listener(self)
#start the game.
self.nextProf()
self.taskMgr.add(self.rodney.mouse_control_event, "mouseShootingEvent")
self.handler = CollisionHandlerQueue()
self.traverser = CollisionTraverser('check projectiles')
self.cTrav = self.traverser
def __init__(self, id=None, data=None):
if data is None:
data = {}
self.listeners = []
self.attributes = data
self.id = id
listenerA = Listener("<Crud Notification>", self)
def main(arglist):
logging.basicConfig(
format='%(funcName)s:%(lineno)d %(levelname)s %(message)s',
level=logging.INFO)
parser = argparse.ArgumentParser()
parser.add_argument('--mode',
dest='mode',
default=RUN_MODE.UPLOAD,
help='The mdoe to run Good drive uploader',
choices=RUN_MODE.CHOICES)
parser.add_argument('--upload',
dest='upload',
default='',
help='Upload a file or directory')
args = parser.parse_args(arglist[1:])
if args.mode == RUN_MODE.UPLOAD:
if not args.upload:
raise ValueError('params --upload required')
GoogleDriveUpload.upload_in_shared(args.upload)
elif args.mode == RUN_MODE.LISTENER:
PORT = 4242
IP = '127.0.0.1'
uploader = GoogleDriveUpload()
listener = Listener(IP, PORT, uploader)
listener.listen()
def main():
global EXIT
subscription = Subscriber()
subscription.subscribe('/queue/analytics/hour', 'report_',
Listener(subscription, action))
while not EXIT:
pass
def listen(self) -> Listener:
"""Listen (Passive open) is the Action of waiting for Connections from remote Endpoints. Before listening
the transport system will resolve transport properties for candidate protocol stacks. A local endpoint must be
passed to the Preconnection prior to listen.
:return: A listener object.
"""
if not self.local_endpoint:
shim_print("Listen error - Local Endpoint MUST be specified if when calling listen on the preconnection", level="error")
backend.clean_up(self.__context)
sys.exit(1)
candidates = self.transport_properties.select_protocol_stacks_with_selection_properties()
if candidates is None:
shim_print("Unfulfilled error - No stacks meeting the given constraints by properties", level="error")
if self.unfulfilled_handler:
self.unfulfilled_handler()
else:
backend.clean_up(self.__context)
backend.pass_candidates_to_back_end(candidates, self.__context, self.__flow)
if self.security_parameteres:
self.register_security(is_server=True)
shim_print("LISTEN!")
listener = Listener(self.__context, self.__flow, self.__ops, self)
return listener
def __run_local(self, state, interface):
"""
Perform command.
This is for executing command on local machine, which means it will not interact with Listener.
:param: state State
:param: interface A file path used as an interface between an agent and an external attack script.
:return: Dict state
"""
command = self.__get_command(state)
args = shlex.split(command)
args.append(interface)
with open(os.devnull, "wb") as err:
subprocess.Popen(args, stdout=err, stderr=err).communicate()
with open(interface, "r") as f:
state = json.load(f)
if self.__get_recv() == "interface":
pass
elif self.__get_recv() == "shell":
shell_state = Listener().get_state(state["address"])
if shell_state != None:
state["shell"] = shell_state
else:
raise RuntimeError("NOT IMPLEMENTED")
return state
def run(self):
self.is_running = True
if self.is_listening:
if self.is_verbose:
print "\033[34m[*]\033[0m starting the listener ...."
''' START Listener '''
self.listener = Listener(open_sock=self.sock,
isVerbose=self.is_verbose)
self.listener.daemon = True
self.listener.start()
if self.is_verbose:
print "\033[34m[*]\033[0m starting the sender ...."
''' START Sender'''
self.sender = Sender(sock=self.sock,
messages=self.messages,
peers=self.peer,
isVerbose=self.is_verbose,
msg_freq=self.msgs_freq,
wait_time=self.wait_time,
gtp_port=self.gtp_port)
self.sender_daemon = True
self.sender.start()
self.sender.join()
time.sleep(5)
self.stop()
def __init__(self,
name,
color,
verbose=True,
silent=False,
menu_path=None):
"""
Constructor
:param name: the bot's name it will use in the dialogues
:param color: the color the bot will use in the prompt
:param verbose: whether the bot should print info about
the command it receives (dependency tree, lemmas info)
:param silent: if true, then only use print (no text to speech)
:param menu_path: the path of the stored menu
"""
self._name = name
self._speaker = Speaker(rate=150, volume=1)
self._listener = Listener(mic_index=0)
self._prompt = colored(f'{self._name}: ', color)
self._verbose = verbose
self._silent = silent
self._frame_stack = []
self._current_frame = None
self._is_over = False
if menu_path is not None:
self._load_menu(menu_path)
else:
self._menu = {"entries": []}
# when finished setup, welcome user
self._say(self._welcome())
def start(self):
self.running = True
conn_listener = Listener(self.index, self.port, self.clock)
conn_listener.start()
for i in range(constants.EVENTS_COUNT):
if not self.running:
break
sleep(min(random.random() + 0.5, 1))
self.clock.increment()
if random.random() > self.chance:
# local
self.logger.info(f"{perf_counter_ns() // 1000} {self.index} {self.clock.get()}{self.index} l")
else:
# remote
idx, node = self.get_node()
try:
self.send_message(idx, node)
except SocketTimeout:
print(
f"""Error: Timeout sending message to node {idx} ({node["host"]}:{node["port"]})"""
)
break
conn_listener.stop()
def add_macro():
global database, listenter
name = request.form.get("name")
language = request.form.get("language")
age_group = request.form.get("age")
gender = request.form.get("gender")
description = request.form.get("description")
keyboard_events_path = request.form.get("key_file")
event_strings = request.form.get("events_string")
sound_1 = request.form.get("sound_1")
sound_2 = request.form.get("sound_2")
sound_3 = request.form.get("sound_3")
ok, message = training_service.get_model(name, (sound_1, sound_2, sound_3),
language, age_group, gender)
if (not ok):
return jsonify({"message": message})
else:
try:
database.insert((name, language, age_group, gender, description,
event_strings, keyboard_events_path, message))
try:
listenter.stop()
except Exception as e:
pass
if (len(database.get_all()) > 0):
listenter = Listener(sensitivity=args.sensitivity,
speed_factor=args.speed_factor)
listenter.start()
return jsonify({"message": "ok"})
except sqlite3.Error as e:
return jsonify({"message": e.args[0]})
def __init__(self, database: DB):
if not isinstance(database, DB):
raise TypeError('Controller was not supplied a DB object')
self.manifest = Manifest()
self.request_queue = multiprocessing.Queue()
self.listener = Listener(self.request_queue)
self.database = database
def get_audio_information(self, audio):
# TODO: Mudar para diretorio apropriado
directory = './audios/'
audio_data = Listener("{}{}".format(directory, audio),
option="gender",
save_into="./received_audio_data.csv")
return self.normalize('dataset.csv', audio_data,
'received_audio_data.csv')
def main():
global EXIT
subscription = Subscriber()
subscription.subscribe('/queue/source', 'clean',
Listener(subscription, action))
while not EXIT:
pass
subscription.disconnect()
def __init__(self, is_debug):
self.__init_base_services(is_debug)
self.__init_plugins()
self.__init_apps()
self.last_msg = time.time()
self.__monitoring_thread = threading.Thread(target=self.monitor_apps,
daemon=True)
self.__monitoring_thread.start()
self.__listener = Listener(self)
def main(argv):
input = FileStream(argv[1])
lexer = YailLexer(input)
stream = CommonTokenStream(lexer)
parser = YailParser(stream)
tree = parser.prog()
listener = Listener()
walker = ParseTreeWalker()
walker.walk(listener, tree)
def _listener(arguments):
"""
Listener subcommand callback
"""
logging.info('Starting Listener')
listener = Listener(silence_time=arguments.silence_time,
threshold=arguments.threshold,
filename_prefix=arguments.filename_prefix)
listener.get_utterance()
def start_to_listen():
with open('credentials/twitter-api.json') as json_file:
#Open credentials and insert api keys
twitter_apiKeys = json.load(json_file)
print("\n ===== Hey there, I'll start to listen to tweets about Joker ===== \n")
print(" Press ctrl+C when you want me to stop!! ")
mylistener = Listener(twitter_apiKeys)
mylistener.set_authentication()
mylistener.start_listening()
