def _ws_connect(self):
self._connect_event.clear()
self.ws = websocket.WebSocketApp(
"ws{0}://{1}:{2}/_/ws/events/json".format(
's' if self.rpc.use_ssl else '', self.rpc.host, self.rpc.port),
header=self.rpc.headers,
on_close=self._on_close,
on_error=self._on_error,
on_message=self._on_message,
on_open=self._on_open)
new_thread = utilities.Thread(target=self.ws.run_forever,
kwargs={
'http_no_proxy': (self.rpc.host, ),
'sslopt': {
'cert_reqs': ssl.CERT_NONE
}
})
new_thread.daemon = True
new_thread.start()
if not self._connect_event.wait(10):
self.logger.error('failed to connect to the server event socket')
return False
self._worker_thread = new_thread
self.logger.debug('successfully connected to the server event socket')
for event_id, subscription_table in self._subscriptions.items():
event_types = set(sub.event_type for sub in subscription_table)
attributes = set(sub.attribute for sub in subscription_table)
self._subscribe(event_id, event_types, attributes)
return True
def load_campaign_information(self, force=True):
"""
Load the necessary campaign information from the remote server.
Unless *force* is True, the :py:attr:`~.last_load_time` is compared with
the :py:attr:`~.refresh_frequency` to check if the information is stale.
If the local data is not stale, this function will return without
updating the table.
:param bool force: Ignore the load life time and force loading the remote data.
"""
if not force and (
(time.time() - self.last_load_time) < self.refresh_frequency):
return
if not self.application.rpc:
self.logger.warning(
'skipping load_campaign_information because rpc is not initialized'
)
return
with self.loader_thread_lock:
self._sync_loader_thread()
self.loader_thread_stop.clear()
self.loader_thread = utilities.Thread(
target=self.loader_thread_routine)
self.loader_thread.daemon = True
self.loader_thread.start()
def __init__(self, *args, **kwargs):
self.logger = logging.getLogger('KingPhisher.Client.RPC')
super(KingPhisherRPCClient, self).__init__(*args, **kwargs)
self.set_serializer('binary/message-pack')
self._async_queue = queue.Queue()
self._async_thread = utilities.Thread(
target=self._async_thread_routine, name='RPCAsyncWorker')
self._async_thread.start()
def __init__(self, *args, **kwargs):
super(PluginManagerWindow, self).__init__(*args, **kwargs)
treeview = self.gobjects['treeview_plugins']
self.status_bar = self.gobjects['statusbar']
self._module_errors = {}
tvm = managers.TreeViewManager(treeview, cb_refresh=self._load_plugins)
toggle_renderer_enable = Gtk.CellRendererToggle()
toggle_renderer_enable.connect('toggled',
self.signal_renderer_toggled_enable)
toggle_renderer_install = Gtk.CellRendererToggle()
toggle_renderer_install.connect('toggled',
self.signal_renderer_toggled_install)
tvm.set_column_titles(
['Installed', 'Enabled', 'Title', 'Compatible', 'Version'],
column_offset=1,
renderers=[
toggle_renderer_install, toggle_renderer_enable,
Gtk.CellRendererText(),
Gtk.CellRendererText(),
Gtk.CellRendererText()
])
tvm.column_views['Enabled'].set_cell_data_func(
toggle_renderer_enable, self._toggle_cell_data_func)
tvm.column_views['Enabled'].add_attribute(toggle_renderer_enable,
'visible', 6)
tvm.column_views['Enabled'].add_attribute(toggle_renderer_enable,
'sensitive', 1)
tvm.column_views['Installed'].add_attribute(toggle_renderer_install,
'visible', 7)
tvm.column_views['Installed'].add_attribute(toggle_renderer_install,
'sensitive', 8)
self._model = Gtk.TreeStore(str, bool, bool, str, str, str, bool, bool,
bool, str)
self._model.set_sort_column_id(3, Gtk.SortType.ASCENDING)
treeview.set_model(self._model)
self.plugin_path = os.path.join(self.application.user_data_path,
'plugins')
self.load_thread = utilities.Thread(target=self._load_catalogs)
self.load_thread.start()
self.popup_menu = tvm.get_popup_menu()
self.popup_menu.append(Gtk.SeparatorMenuItem())
menu_item = Gtk.MenuItem.new_with_label('Reload')
menu_item.connect('activate', self.signal_popup_menu_activate_reload)
self.popup_menu.append(menu_item)
menu_item_reload_all = Gtk.MenuItem.new_with_label('Reload All')
menu_item_reload_all.connect(
'activate', self.signal_popup_menu_activate_reload_all)
self.popup_menu.append(menu_item_reload_all)
self.popup_menu.show_all()
self._update_status_bar('Loading...')
self.window.show()
selection = treeview.get_selection()
selection.unselect_all()
paned = self.gobjects['paned_plugins']
self._paned_offset = paned.get_allocation(
).height - paned.get_position()
def _worker_thread_start(self, target, *args, **kwargs):
"""
Start a worker thread. This must only be called from the main GUI thread
and *target* must be a tsafe method.
"""
if not self._worker_thread_is_ready:
self._show_dialog_busy()
self.logger.debug(
'plugin manager worker thread is alive, can not start a new one'
)
return False
self._worker_thread = utilities.Thread(target=target,
args=args,
kwargs=kwargs)
self._worker_thread.start()
return True
def load_campaign_information(self, force=True): """ Load the necessary campaign information from the remote server. Unless *force* is True, the :py:attr:`~.CampaignViewGenericTab.last_load_time` is compared with the :py:attr:`~.CampaignViewGenericTab.refresh_frequency` to check if the information is stale. If the local data is not stale, this function will return without updating the table. :param bool force: Ignore the load life time and force loading the remote data. """ if not force and ((time.time() - self.last_load_time) < self.refresh_frequency): return with self.loader_thread_lock: self._sync_loader_thread() self.loader_thread_stop.clear() self._tv_model.clear() self.loader_thread = utilities.Thread(target=self.loader_thread_routine, args=(self._tv_model,)) self.loader_thread.daemon = True self.loader_thread.start() return
def signal_popup_menu_activate_reload(self, _):
if not self.load_thread.is_alive():
self.load_thread = utilities.Thread(target=self._reload)
self.load_thread.start()
def signal_popup_menu_activate_reload_all(self, _):
if not self.load_thread.is_alive():
self.load_thread = utilities.Thread(target=self._load_catalogs,
kwargs={'refresh': True})
self.load_thread.start()
def on_server_initialized(self, server):
self._worker_thread = utilities.Thread(
target=self.check_file_change, args=(self.config['log_file'], ))
self._worker_thread.start()
