def add_user(_authorization_file, bot_name, group, user_id, bot_oauth_token):
try:
with open(_authorization_file) as file:
authorized_ids = json.load(file)
except:
script_name = path.basename(__file__)
text = '`Authorization file not found`'
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
cmd='Delete userID',
status='Failed',
result=text,
auth='Denied')
else:
if group in authorized_ids.keys():
if user_id not in authorized_ids[group]['user_ids']:
user = auth_ops.slack_valid_user(bot_oauth_token, user_id,
bot_name)
if user:
authorized_ids[group]['user_ids'].append(user_id)
file = open(_authorization_file, "w")
json.dump(authorized_ids, file)
file.close()
return "```User \"{}\" added to group \"{}\"```".format(
user, group)
else:
return "`userID does not exist in Slack`"
else:
return "`userID already in group`"
else:
return "`Invalid group`"
def send_file(slack_client, channel, filename, bot_name, title,
initial_comment):
# Sends the response back to the channel
script_name = os.path.basename(__file__)
# noinspection PyBroadException
text = 'test'
try:
slack_client.api_call("files.upload",
channel=channel,
title='Automated Inventory Collection',
file=filename)
#slack_client.api_call("chat.postMessage", channel=channel, text=text)
with open(filename, 'rb') as f:
slack_client.api_call("files.upload",
channels=channel,
filename=filename,
title=title,
initial_comment=initial_comment,
file=io.BytesIO(f.read()))
except Exception:
trace_string = traceback.format_exc()
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
cmd='Send message to Slack',
status='Failed',
result="Failed\n" + trace_string + "\n")
def delete_user(_authorization_file, bot_name, user_id):
found = False
try:
with open(_authorization_file) as file:
authorized_ids = json.load(file)
except:
script_name = path.basename(__file__)
text = '`Authorization file not found`'
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
cmd='Delete userID',
status='Failed',
result=text,
auth='Denied')
else:
for group_id in authorized_ids.keys():
if user_id in authorized_ids[group_id]['user_ids']:
authorized_ids[group_id]['user_ids'].remove(user_id)
found = True
if found:
file = open(_authorization_file, "w")
json.dump(authorized_ids, file)
file.close()
return "```User deleted```"
else:
return "`User not found`"
def list_users(_authorization_file, bot_name, bot_oauth_token):
text = ""
try:
with open(_authorization_file) as file:
authorized_ids = json.load(file)
except:
script_name = path.basename(__file__)
text = '`Authorization file not found`'
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
cmd='List userIDs',
status='Failed',
result=text,
auth='Denied')
else:
for group_id in authorized_ids.keys():
text += "* Group name: {}\n".format(group_id)
text += "Commands: {}\n".format(
str(authorized_ids[group_id]['cmds']))
if group_id != 'free':
text += "Users:\n"
for item in authorized_ids[group_id]['user_ids']:
username, user_email = auth_ops.get_slack_user_info(
bot_oauth_token, item, bot_name)
text += f"{item} - {username} - {user_email}\n"
text += "\n"
else:
text += "Users: all\n"
text = "```" + text + "```"
return text
def get_slack_user_name(bot_oauth_token, slack_user_id, bot_name):
script_name = path.basename(__file__)
payload = {'token': bot_oauth_token, 'user': slack_user_id}
response = requests.get('https://slack.com/api/users.info', params=payload)
response_to_dict = json.loads(response.text)
# noinspection PyBroadException
try:
return response_to_dict['user']['real_name']
except Exception:
trace_string = traceback.format_exc()
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
cmd='Query username',
status='Failed',
result=trace_string,
auth='Approved')
def run(**kwargs):
script_name = path.basename(__file__)
command_splited = kwargs['command_splited']
slack_client = kwargs['slack_client']
channel = kwargs['channel']
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Ok',
result='Starting')
if len(command_splited) == 1:
string_filter = ''
validate_hosts_ops.list_inventory(slack_client, channel, string_filter,
kwargs['bot_cmd_log_file'],
kwargs['username'],
kwargs['command'],
kwargs['bot_name'])
elif len(command_splited) == 2:
string_filter = command_splited[1]
string_filter = string_filter.replace('*', '.*')
validate_hosts_ops.list_inventory(slack_client, channel, string_filter,
kwargs['bot_cmd_log_file'],
kwargs['username'],
kwargs['command'],
kwargs['bot_name'])
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Syntax`",
kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result='Invalid Syntax')
def authorize_json(_authorization_file, user_id, bot_name):
try:
with open(_authorization_file) as file:
authorized_ids = json.load(file)
except:
script_name = path.basename(__file__)
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
cmd='Authorize userID',
status='Failed',
result='Authorization file not found',
auth='Denied')
return False, []
else:
for group_id in authorized_ids.keys():
if user_id in authorized_ids[group_id]['user_ids']:
return group_id, authorized_ids[group_id]['cmds']
return 'free', authorized_ids['free']['cmds']
def run(**kwargs):
script_name = path.basename(__file__)
command_splited = kwargs['command_splited']
slack_client = kwargs['slack_client']
channel = kwargs['channel']
log_ops.log_msg(bot_name=kwargs['bot_name'], script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'], channel=channel, username=kwargs['username'],
cmd=kwargs['command'], auth='Approved', status='Ok', result='Starting')
if len(command_splited) >= 3 and str(command_splited[-1]).endswith("\"") and\
str(command_splited[2]).startswith("\""):
source = command_splited[1]
valid_source = validate_hosts_ops.verify_source_in_inventory(source)
if valid_source:
join_cmd = command_splited[2:]
pre_cmd = ""
for item in join_cmd:
pre_cmd += item + " "
final_cmd = pre_cmd[1:-2]
if len(final_cmd) < 51:
if final_cmd.startswith("sh"):
playbook = "net-ios-show-msg-slack.yml"
bot_playbooks_directory = kwargs['bot_playbooks_directory']
playbook_full_path = bot_playbooks_directory + playbook
ansible_common_inventory_full_path_name = kwargs['ansible_common_inventory_full_path_name']
json = True
ansible_ops.ansible_cmd(json, playbook_full_path, ansible_common_inventory_full_path_name, channel,
slack_client, kwargs['username'], kwargs['bot_name'],
kwargs['bot_cmd_log_file'],
source=source, cmd=final_cmd)
else:
slack_ops.send_msg(slack_client, channel, "`Command too long, max. 50 characters`", kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'], script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'], channel=channel,
username=kwargs['username'],
cmd=kwargs['command'], auth='Approved', status='Failed',
result='Command too long, max. 50 characters')
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Device`", kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'], script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'], channel=channel, username=kwargs['username'],
cmd=kwargs['command'], auth='Approved', status='Failed', result='Invalid Device')
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Syntax`", kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'], script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'], channel=channel, username=kwargs['username'],
cmd=kwargs['command'], auth='Approved', status='Failed', result='Invalid Syntax')
def run(**kwargs):
script_name = path.basename(__file__)
command_splited = kwargs['command_splited']
slack_client = kwargs['slack_client']
channel = kwargs['channel']
text = ''
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Ok',
result='Starting')
if len(command_splited) == 2 and command_splited[1] == 'list':
text = list_users(kwargs['bot_authorized_users_file'],
kwargs['bot_name'], kwargs['bot_oauth_token'])
status = 'OK'
elif len(command_splited) == 3 and command_splited[1] == 'delete':
text = delete_user(kwargs['bot_authorized_users_file'],
kwargs['bot_name'], command_splited[2])
status = 'OK'
elif len(command_splited) == 4 and command_splited[1] == 'add':
text = add_user(kwargs['bot_authorized_users_file'],
kwargs['bot_name'], command_splited[2],
command_splited[3], kwargs['bot_oauth_token'])
status = 'OK'
else:
text = "`Invalid Syntax`"
status = 'Failed'
slack_ops.send_msg(slack_client, channel, text, kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status=status,
result=text)
def authorize_txt(_authorization_file, item_id, bot_name):
try:
file = open(_authorization_file, 'r')
authorized_ids = file.read()
file.close()
except:
script_name = path.basename(__file__)
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
cmd='Authorize userID',
status='Failed',
result='Authorization file not found',
auth='Denied')
return False, []
else:
if item_id in authorized_ids:
return "neteng", []
else:
return False, []
def send_msg(slack_client, channel, response, bot_name):
# Sends the response back to the channel
script_name = os.path.basename(__file__)
# noinspection PyBroadException
if len(response) <= 3800:
try:
slack_client.api_call("chat.postMessage",
channel=channel,
text=response)
except Exception:
trace_string = traceback.format_exc()
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
cmd='Send message to Slack',
status='Failed',
result="Failed\n" + trace_string + "\n")
else:
if response.startswith('```'):
response = response[3:-3]
is_error = False
else:
response = response[1:-1]
is_error = True
step = 3800
response_list = []
for i in range(0, len(response), 3800):
response_list.append(response[i:step])
step += 3800
for i in range(0, len(response_list)):
if is_error:
text = '`' + response_list[i] + '`'
else:
text = '```' + response_list[i] + '```'
slack_client.api_call("chat.postMessage",
channel=channel,
text=text)
time.sleep(1)
def run(**kwargs):
script_name = path.basename(__file__)
command_splited = kwargs['command_splited']
slack_client = kwargs['slack_client']
channel = kwargs['channel']
log_ops.log_msg(bot_name=kwargs['bot_name'], script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'], channel=channel, username=kwargs['username'],
cmd=kwargs['command'], auth='Approved', status='Ok', result='Starting')
if len(command_splited) == 3:
source = command_splited[1]
valid_source = validate_hosts_ops.verify_source_in_inventory(source)
if valid_source:
destination = command_splited[2]
valid_destination = validate_hosts_ops.verify_host_address(destination)
if valid_destination:
playbook = "net-trace-msg-slack.yml"
bot_playbooks_directory = kwargs['bot_playbooks_directory']
playbook_full_path = bot_playbooks_directory + playbook
ansible_common_inventory_full_path_name = kwargs['ansible_common_inventory_full_path_name']
json = True
ansible_ops.ansible_cmd(json, playbook_full_path, ansible_common_inventory_full_path_name, channel,
slack_client, kwargs['username'], kwargs['bot_name'],
kwargs['bot_cmd_log_file'],
source=source, destination=valid_destination)
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Destination`", kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'], script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'], channel=channel,
username=kwargs['username'],
cmd=kwargs['command'], auth='Approved', status='Failed', result='Invalid Destination')
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Device`", kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'], script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'], channel=channel, username=kwargs['username'],
cmd=kwargs['command'], auth='Approved', status='Failed', result='Invalid Device')
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Syntax`", kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'], script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'], channel=channel, username=kwargs['username'],
cmd=kwargs['command'], auth='Approved', status='Failed', result='Invalid Syntax')
def run(self):
script_name = path.basename(__file__)
proc = subprocess.Popen(self.cmd,
shell=True,
stdout=sys.stdout,
stderr=sys.stdout,
universal_newlines=True)
# pid = proc.pid
slack_ops.send_msg(
self.slack_client, self.channel,
"```Executing command - TaskID={}```".format(str(self.task_id)),
self.bot_name)
log_ops.log_msg(bot_cmd_log_file=self.bot_cmd_log_file,
script_name=script_name,
bot_name=self.bot_name,
username=self.username,
channel=self.channel,
cmd=self.cmd,
task_id=self.task_id,
status="Ok",
result="Running")
while proc.poll() is None:
time.sleep(2)
msg = "Command finished - TaskID={}".format(str(self.task_id))
slack_ops.send_msg(self.slack_client, self.channel,
"```{}```".format(msg), self.bot_name)
log_ops.log_msg(bot_cmd_log_file=self.bot_cmd_log_file,
script_name=script_name,
bot_name=self.bot_name,
username=self.username,
channel=self.channel,
cmd=self.cmd,
task_id=self.task_id,
status="Ok",
result="Finished")
def ansible_cmd(json, playbook_full_path_name,
ansible_common_inventory_full_path_name, channel, slack_client,
username, bot_name, bot_cmd_log_file, **kwargs):
script_name = path.basename(__file__)
cmd = "ansible-playbook " + playbook_full_path_name + \
" -i " + ansible_common_inventory_full_path_name + " --extra-vars \""
task_id = randint(0, 999999)
if json:
extra_vars_json = {key: value for key, value in kwargs.items()}
extra_vars_json["channel"] = channel
extra_vars_json["username"] = username
extra_vars_json["bot_name"] = bot_name
extra_vars_json["task_id"] = task_id
cmd += str(extra_vars_json) + "\" -vvvv"
else:
for key, value in kwargs.items():
cmd += key + "=" + str(value) + " "
cmd += "channel=" + channel + " username="******" bot_name=" + bot_name + " task_id=" + str(
task_id) + "\" -vvvv"
process_name = "ansible-playbook"
if scheduler.go(process_name):
thread = AnsibleExecThread(slack_client, channel, cmd, username,
bot_name, bot_cmd_log_file, task_id)
thread.start()
else:
msg = "Scheduler: Can't launch task, too many running, wait a couple of minutes and try again"
slack_ops.send_msg(slack_client, channel, "```{}```".format(msg),
bot_name)
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
username=username,
channel=channel,
status="Failed",
result='Scheduler: Too many tasks running')
def python3_cmd(cmd, channel, slack_client, username, bot_name,
bot_cmd_log_file, **kwargs):
script_name = path.basename(__file__)
task_id = randint(0, 999999)
cmd += " {} {} {} {}".format(channel, username, bot_name, task_id)
process_name = "python3"
if scheduler.go(process_name):
thread = Python3ExecThread(slack_client, channel, cmd, username,
bot_name, bot_cmd_log_file, task_id)
thread.start()
else:
msg = "Scheduler: Can't launch task, too many running, wait a couple of minutes and try again"
slack_ops.send_msg(slack_client, channel, "```{}```".format(msg),
bot_name)
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
username=username,
channel=channel,
status="Failed",
result='Scheduler: Too many tasks running')
def run(**kwargs):
script_name = path.basename(__file__)
discovered_plugins = kwargs['discovered_plugins']
command_splited = kwargs['command_splited']
slack_client = kwargs['slack_client']
channel = kwargs['channel']
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Ok',
result='Starting')
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Ok',
result='Running')
if len(command_splited) == 1:
response = "```This is the available list of commands:\n"
for cmd, value in discovered_plugins.items():
if kwargs['user_group'] == 'neteng':
response += "- " + value.command_syntax() + "\n"
elif cmd in kwargs['auth_cmds']:
response += "- " + value.command_syntax() + "\n"
response += "```"
elif command_splited[1].replace(".", "_") not in discovered_plugins.keys():
response = "`The command \"{}\" don't exists. Try \"@botnet help\" to view available commands`".format(
command_splited[1])
slack_ops.send_msg(slack_client, channel, response, kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result=response)
return
else:
response = "```" + discovered_plugins[command_splited[1].replace(
'.', '_')].command_help() + "```"
slack_ops.send_msg(slack_client, channel, response, kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Ok',
result='Finished')
print('no')
else:
text = "Device \"{}\"".format(source)
ip_host_mask = ip_address.split()[1] + " 255.255.255.255"
if ip_address in output.lower() or ip_host_mask in output.lower():
print('yes')
text = "Removing from object group"
status = 'Ok'
result = 'Parsed'
else:
print('no')
status = 'Not Found'
result = 'Parsed'
text += " - IP " + ip_address + " not in group \"" + object_group + "\""
text = "`" + text + "`"
if status == 'Failed' or status == 'Not Found':
slack_ops.send_msg(slack_client, channel, text, bot_name)
print("Text= " + text)
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
bot_cmd_log_file=bot_cmd_log_file,
channel=channel,
username=username,
cmd=sys.argv[0],
auth='Approved',
status=status,
result=result,
task_id=task_id)
def run(**kwargs):
script_name = path.basename(__file__)
command_splited = kwargs['command_splited']
slack_client = kwargs['slack_client']
channel = kwargs['channel']
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Ok',
result='Starting')
if len(command_splited) >= 3 and str(command_splited[-1]).endswith("\"") and\
str(command_splited[2]).startswith("\""):
sources = re.search(r'src=(.*)', command_splited[1])
destinations = "dummy"
if sources and destinations:
list_sources, sources_count, list_destinations, destinations_count =\
validate_hosts_ops.identify_elements(sources[1], destinations[1])
if sources_count != 0:
if sources_count <= int(kwargs['max_devices']):
join_cmd = command_splited[2:]
pre_cmd = ""
for item in join_cmd:
pre_cmd += item + " "
final_cmd = pre_cmd[1:-2]
if len(final_cmd) < 51:
if final_cmd.startswith("show"):
playbook = "net-ios-show-msg-slack.yml"
bot_playbooks_directory = kwargs[
'bot_playbooks_directory']
playbook_full_path = bot_playbooks_directory + playbook
ansible_common_inventory_full_path_name = kwargs[
'ansible_common_inventory_full_path_name']
json = True
ansible_ops.ansible_cmd(
json,
playbook_full_path,
ansible_common_inventory_full_path_name,
channel,
slack_client,
kwargs['username'],
kwargs['bot_name'],
kwargs['bot_cmd_log_file'],
source=list(list_sources),
cmd=final_cmd)
else:
slack_ops.send_msg(
slack_client, channel,
"`Command too long, max. 50 characters`",
kwargs['bot_name'])
log_ops.log_msg(
bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result='Command too long, max. 50 characters')
else:
slack_ops.send_msg(
slack_client, channel,
"`Too many devices. Max {}`".format(
kwargs['max_devices']), kwargs['bot_name'])
log_ops.log_msg(
bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result='Too many devices. Max {}'.format(
kwargs['max_devices']))
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Sources`",
kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result='Invalid Sources')
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Devices`",
kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result='Invalid Devices')
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Syntax`",
kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result='Invalid Syntax')
def list_inventory(slack_client, channel, string_filter, bot_cmd_log_file,
username, cmd, bot_name):
text = ""
is_first = True
script_name = os.path.basename(__file__)
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
bot_cmd_log_file=bot_cmd_log_file,
channel=channel,
username=username,
cmd=cmd,
auth='Approved',
status='Ok',
result='Running')
if string_filter == '':
text = "```"
with open(_PYCHATOPS_HOME_DIRECTORY + "devices/hosts", "r") as file:
for line in file:
if '[' in line:
match = re.search(r'\[(.*)\]', line)
if match:
if is_first:
text += "\n=========================================================\n" + \
"| {:<53} |".format(match.group(1).lower()) \
+ "\n=========================================================\n"
is_first = False
else:
text += "=========================================================\n" + \
"\n=========================================================\n" + \
"| {:<53} |".format(match.group(1).lower()) \
+ "\n=========================================================\n"
match = re.search(
r'(.*) ansible_host=([^\s]+)(.*)platform=([^\s]+)', line)
if match:
text += '| {:<20} | {:<18} | {:<8} |\n'.format(
match[1], match[2], match[4])
text += "=========================================================```"
else:
with open(_PYCHATOPS_HOME_DIRECTORY + "devices/hosts", "r") as file:
for line in file:
if '[' in line:
continue
match_line = re.search(string_filter, line)
if match_line:
match_capture_detail = re.search(
r'(.*) ansible_host=([^\s]+)(.*)platform=([^\s]+)',
line)
if match_capture_detail:
text += '| {:<20} | {:<18} | {:<8} |\n'.format(
match_capture_detail[1], match_capture_detail[2],
match_capture_detail[4])
text += ""
if len(text) == 0:
text = "`No matching devices`"
else:
text = "```" + text + "```"
slack_ops.send_msg(slack_client, channel, text, bot_name)
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
bot_cmd_log_file=bot_cmd_log_file,
channel=channel,
username=username,
cmd=cmd,
auth='Approved',
status='Ok',
result='Finished')
def run(**kwargs):
script_name = path.basename(__file__)
command_splited = kwargs['command_splited']
slack_client = kwargs['slack_client']
channel = kwargs['channel']
log_ops.log_msg(bot_name=kwargs['bot_name'], script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'], channel=channel, username=kwargs['username'],
cmd=kwargs['command'], auth='Approved', status='Ok', result='Starting')
if 2 <= len(command_splited) <= 3:
ip = command_splited[1]
valid_ip = validate_hosts_ops.verify_host_address(ip)
ip_text = ''
if valid_ip:
if len(command_splited) == 3:
if command_splited[2].isnumeric():
if 24 <= int(command_splited[2]) <= 31:
ip_data = ipaddress.ip_network(valid_ip + "/" + command_splited[2], strict=False)
ip_data = ip_data.with_netmask
ip_data = str(ip_data)
ip_data = ip_data.split('/')
valid_subnet = True
ip_text = ip_data[0] + " " + ip_data[1]
else:
valid_subnet = False
else:
valid_subnet = False
else:
ip_text = "host " + valid_ip
valid_subnet = True
if valid_ip and valid_subnet:
playbook = "net-asa-no-obj-grp-msg-slack.yml"
bot_playbooks_directory = kwargs['bot_playbooks_directory']
playbook_full_path = bot_playbooks_directory + playbook
json = True
source = 'all'
ip_address = ip_text
object_group = "blacklist"
ansible_common_inventory_full_path_name = kwargs['ansible_common_inventory_full_path_name']
ansible_ops.ansible_cmd(json, playbook_full_path, ansible_common_inventory_full_path_name, channel,
slack_client, kwargs['username'], kwargs['bot_name'], kwargs['bot_cmd_log_file'],
ip_address=ip_address, object_group=object_group, source=source, function='remove')
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Subnet`", kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'], script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'], channel=channel, username=kwargs['username'],
cmd=kwargs['command'], auth='Approved', status='Failed', result='Invalid Subnet')
else:
slack_ops.send_msg(slack_client, channel, "`Invalid IP address`", kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'], script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'], channel=channel, username=kwargs['username'],
cmd=kwargs['command'], auth='Approved', status='Failed', result='Invalid IP address')
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Syntax. Try \"@botnet help block.ip\"`", kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'], script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'], channel=channel, username=kwargs['username'],
cmd=kwargs['command'], auth='Approved', status='Failed', result='Invalid Syntax')
def start(**kwargs):
script_name = path.basename(__file__)
bot_name = kwargs['bot_name'].lower()
if bot_name == 'net':
_RTM_READ_DELAY = 0.1
else:
_RTM_READ_DELAY = rtm_read_delay
bot_log_file = _PYCHATOPS_HOME_DIRECTORY + config['Slack']['bot_' +
bot_name +
'_log_file']
bot_cmd_log_file = config['Slack']['bot_' + bot_name + '_cmd_log']
bot_oauth_token = config['Slack']['bot_' + bot_name + '_oauth']
bot_playbooks_directory = _PYCHATOPS_HOME_DIRECTORY + config['Slack'][
'bot_' + bot_name + '_ansible_playbooks_full_path_name']
bot_authorized_users_file = _PYCHATOPS_HOME_DIRECTORY + config['Slack'][
'bot_' + bot_name + '_authorized_users_file']
extra_data_file = _PYCHATOPS_HOME_DIRECTORY + config['Slack'][
'bot_' + bot_name + '_extra_data_file']
# sys.stdout = open(bot_log_file, 'a+')
plugins_path = bots_directory + bot_name.lower() + "/"
if plugins_path not in sys.path:
sys.path.insert(0, plugins_path)
discovered_plugins = {
name: importlib.import_module(name)
for finder, name, ispkg in pkgutil.iter_modules([plugins_path])
# if name.startswith('user_') or name.startswith('help')
}
log_ops.log_msg(bot_cmd_log_file=bot_cmd_log_file,
status='Ok',
username='******',
bot_name=bot_name,
script_name=script_name,
cmd='Start Bot',
result="Started")
slack_client = SlackClient(bot_oauth_token)
if slack_client.rtm_connect(with_team_state=False):
log_ops.log_msg(bot_cmd_log_file=bot_cmd_log_file,
status='Ok',
bot_name=bot_name,
script_name=script_name,
username='******',
cmd='Connect to Slack',
result="Bot Started and Running!")
# Read bot's user ID by calling Web API method `auth.test`
starterbot_id = slack_client.api_call("auth.test")["user_id"]
while True:
try:
command, channel, slack_userid = slack_ops.parse_bot_commands(
starterbot_id, slack_client.rtm_read())
except Exception:
trace_string = traceback.format_exc()
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
cmd='Connect to Slack',
status='Failed',
username='******',
result="Can't connect\n" + trace_string +
"\nRetrying")
time.sleep(5)
slack_client.rtm_connect(with_team_state=False)
else:
if command:
command_splited = command.split()
command_splited[0] = command_splited[0].replace('.', '_')
username = auth_ops.get_slack_user_name(
bot_oauth_token, slack_userid, bot_name)
if command_splited[0] in discovered_plugins.keys():
if bot_authorized_users_file.endswith('all'):
user_group, auth_cmds = 'neteng', []
elif bot_authorized_users_file.endswith('txt'):
user_group, auth_cmds = auth_ops.authorize_txt(
bot_authorized_users_file, slack_userid,
bot_name)
else:
user_group, auth_cmds = auth_ops.authorize_json(
bot_authorized_users_file, slack_userid,
bot_name)
auth = 'Approved' if user_group else 'Denied'
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
bot_cmd_log_file=bot_cmd_log_file,
channel=channel,
username=username,
cmd=command,
auth=auth,
status='Ok',
result='Command recognized')
if (user_group is not False) and (
(user_group == "neteng") or
(command_splited[0] in auth_cmds)):
discovered_plugins[command_splited[0]].run(
discovered_plugins=discovered_plugins,
command_splited=command_splited,
slack_client=slack_client,
channel=channel,
bot_playbooks_directory=bot_playbooks_directory,
ansible_common_inventory_full_path_name=
ansible_common_inventory_full_path_name,
bots_directory=bots_directory,
netor_home_directory=_PYCHATOPS_HOME_DIRECTORY,
bot_directory=bots_directory + bot_name,
extra_data_file=extra_data_file,
username=username,
user_group=user_group,
bot_cmd_log_file=bot_cmd_log_file,
command=command,
bot_name=bot_name,
multiple_src_dst=multiple_src_dst,
max_devices=max_devices,
auth_cmds=auth_cmds,
bot_authorized_users_file=
bot_authorized_users_file,
bot_oauth_token=bot_oauth_token)
else:
slack_ops.send_msg(
slack_client, channel,
"`User \"{}\" not authorized`".format(
username), bot_name)
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
bot_cmd_log_file=bot_cmd_log_file,
channel=channel,
username=username,
auth=auth,
cmd=command,
status='Failed',
result='User not authorized')
else:
response = "`Command unknown. Try \"@Bot-" + bot_name.upper() + \
" help\" to view available commands.`"
slack_ops.send_msg(slack_client, channel, response,
bot_name)
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
bot_cmd_log_file=bot_cmd_log_file,
channel=channel,
username=username,
cmd=command,
status='Failed',
result='Invalid command')
time.sleep(_RTM_READ_DELAY)
else:
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
username='******',
bot_cmd_log_file=bot_cmd_log_file,
cmd='Connect to Slack',
status='Failed',
result="Bot restart required")
def run(**kwargs):
script_name = path.basename(__file__)
command_splited = kwargs['command_splited']
slack_client = kwargs['slack_client']
channel = kwargs['channel']
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Ok',
result='Starting')
if 3 <= len(command_splited) <= 4:
source = validate_hosts_ops.verify_source_in_inventory(
command_splited[1])
if source:
destination = validate_hosts_ops.verify_host_address(
command_splited[2])
if not destination:
_, destination = validate_hosts_ops.verify_destination_ip_in_inventory(
command_splited[2])
if len(destination) != 0:
destination = list(destination)[0]
if destination:
count = 4
if len(command_splited) == 4 and command_splited[3] <= 100:
count = command_splited[3]
playbook = "net-ping-msg-slack.yml"
bot_playbooks_directory = kwargs['bot_playbooks_directory']
playbook_full_path = bot_playbooks_directory + playbook
json = False
ansible_common_inventory_full_path_name = kwargs[
'ansible_common_inventory_full_path_name']
ansible_ops.ansible_cmd(
json,
playbook_full_path,
ansible_common_inventory_full_path_name,
channel,
slack_client,
kwargs['username'],
kwargs['bot_name'],
kwargs['bot_cmd_log_file'],
source=source,
destination=destination,
count=count)
else:
slack_ops.send_msg(slack_client, channel,
"`Invalid Destination`", kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result='Invalid Destination')
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Source`",
kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result='Invalid Source')
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Syntax`",
kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result='Invalid Syntax')
def main():
text = "Device \"{}\"".format(source)
status = 'Ok'
result = 'Executed'
if function == 'list':
with fmcapi.FMC(host=host,
username=secrets['ansible_user'],
password=secrets['ansible_password'],
autodeploy=True) as fmc:
obj1 = fmcapi.NetworkGroups(fmc=fmc, name=network_group)
response = obj1.get()
if 'id' not in response.keys():
print('Failed Object Group \"{}\" does not exist'.format(
network_group))
else:
print('Object Group \"{}\" Found'.format(network_group))
print(json.dumps(response))
elif function == 'add':
with fmcapi.FMC(host=host,
username=secrets['ansible_user'],
password=secrets['ansible_password'],
autodeploy=False) as fmc:
obj1 = fmcapi.NetworkGroups(fmc=fmc, name=network_group)
response = obj1.get()
#print(json.dumps(obj1.format_data()))
if 'id' not in response.keys():
text += ' - Object Group \"{}\" not found'.format(
network_group)
text = "`" + text + "`"
else:
present = search(response, ip_address)
if not present:
obj1.unnamed_networks(action='add', value=ip_address)
print('Adding IP \"{}\" to object group \"{}\"'.format(
ip_address, network_group))
response = obj1.put()
#print(response)
if response:
print('Verifying add IP \"{}\" to object group \"{}\"'.
format(ip_address, network_group))
response = obj1.get()
present = search(response, ip_address)
if present:
text += ' - IP \"{}\" added to \"{}\"'.format(
ip_address, network_group)
text = "```" + text + "```"
else:
text += ' Failed to add IP \"{}\" to \"{}\"'.format(
ip_address, network_group)
text = "`" + text + "`"
else:
text += ' Failed to add IP \"{}\" to \"{}\"'.format(
ip_address, network_group)
text = "`" + text + "`"
else:
text += ' - IP \"{}\" already exist in \"{}\"'.format(
ip_address, network_group)
text = "`" + text + "`"
elif function == 'remove':
with fmcapi.FMC(host=host,
username=secrets['ansible_user'],
password=secrets['ansible_password'],
autodeploy=True) as fmc:
obj1 = fmcapi.NetworkGroups(fmc=fmc, name=network_group)
response = obj1.get()
#print(json.dumps(obj1.format_data()))
if 'id' not in response.keys():
text += ' - Object Group \"{}\" not found'.format(
network_group)
text = "`" + text + "`"
else:
present = search(response, ip_address)
if not present:
text += ' - IP \"{}\" not in \"{}\"'.format(
ip_address, network_group)
text = "`" + text + "`"
else:
obj1.unnamed_networks(action='remove', value=ip_address)
print('Removing IP \"{}\" to object group \"{}\"'.format(
ip_address, network_group))
response = obj1.put()
#print(response)
if response:
#print(json.dumps(obj1.format_data()))
print(
'Verifying removal IP \"{}\" to object group \"{}\"'
.format(ip_address, network_group))
response = obj1.get()
present = search(response, ip_address)
if not present:
text += ' - IP \"{}\" removed from \"{}\"'.format(
ip_address, network_group)
text = "```" + text + "```"
else:
text += ' - Failed to remove IP \"{}\" from \"{}\"'.format(
ip_address, network_group)
text = "`" + text + "`"
else:
text += ' - Failed to remove IP \"{}\" from \"{}\"'.format(
ip_address, network_group)
text = "`" + text + "`"
else:
print('Invalid option')
slack_ops.send_msg(slack_client, channel, text, bot_name)
print("Text= " + text)
log_ops.log_msg(bot_name=bot_name,
script_name=script_name,
bot_cmd_log_file=bot_cmd_log_file,
channel=channel,
username=username,
cmd=sys.argv[0],
auth='Approved',
status=status,
result=result,
task_id=task_id)
def run(**kwargs):
script_name = path.basename(__file__)
command_splited = kwargs['command_splited']
slack_client = kwargs['slack_client']
channel = kwargs['channel']
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Ok',
result='Starting')
if len(command_splited) >= 3:
sources = re.search(r'src=(.*)', command_splited[1])
destinations = re.search(r'dst=(.*)', command_splited[2])
if sources and destinations:
list_sources, sources_count, list_destinations, destinations_count =\
validate_hosts_ops.identify_elements(sources[1], destinations[1])
total = sources_count * destinations_count
if sources_count != 0 and destinations_count != 0:
if total <= int(kwargs['multiple_src_dst']):
playbook = "net-mtrace-msg-slack.yml"
bot_playbooks_directory = kwargs['bot_playbooks_directory']
playbook_full_path = bot_playbooks_directory + playbook
ansible_common_inventory_full_path_name = kwargs[
'ansible_common_inventory_full_path_name']
json = True
if destinations_count == 1:
ansible_ops.ansible_cmd(
json,
playbook_full_path,
ansible_common_inventory_full_path_name,
channel,
slack_client,
kwargs['username'],
kwargs['bot_name'],
kwargs['bot_cmd_log_file'],
source=list(list_sources),
destination=list(list_destinations)[0])
else:
for item in list_destinations:
ansible_ops.ansible_cmd(
json,
playbook_full_path,
ansible_common_inventory_full_path_name,
channel,
slack_client,
kwargs['username'],
kwargs['bot_name'],
kwargs['bot_cmd_log_file'],
source=list(list_sources),
destination=item)
else:
slack_ops.send_msg(
slack_client, channel,
"`Too many operations. Max {}`".format(
kwargs['multiple_src_dst']), kwargs['bot_name'])
log_ops.log_msg(
bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result='Too many operations. Max {}'.format(
kwargs['multiple_src_dst']))
else:
slack_ops.send_msg(slack_client, channel,
"`Invalid sources or destinations`",
kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result='Invalid sources or destinations')
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Devices`",
kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result='Invalid Devices')
else:
slack_ops.send_msg(slack_client, channel, "`Invalid Syntax`",
kwargs['bot_name'])
log_ops.log_msg(bot_name=kwargs['bot_name'],
script_name=script_name,
bot_cmd_log_file=kwargs['bot_cmd_log_file'],
channel=channel,
username=kwargs['username'],
cmd=kwargs['command'],
auth='Approved',
status='Failed',
result='Invalid Syntax')
