async def reload_extension(self, extension_name):
name = extension_name.replace('-', '.')
try:
self.bot.reload_extension(name)
except discord.ext.commands.errors.ExtensionNotLoaded as e:
logger.exception("Couldn't load extension")
return {"message": f"Extension Not Loaded: {e}"}, sc.SERVICE_UNAVAILABLE_503
return {"message": "Reload signal sent"}, sc.OK_200
async def on_member_join(self, member):
logger.info("%s joined guild: %s" % (member.name, member.guild.name))
settings = self.bot.settings[member.guild]
try:
default_role = discord.utils.get(member.guild.roles, id=settings.default_role_id)
await member.add_roles(default_role)
except Exception:
logger.exception("could not add %s to %s" % (member.display_name, 'default role'))
async def set(self, ctx, *args):
"""
Sets an auto response
use the syntax 'set trigger::response'
check out the docs for advanced options:
https://docs.archit.us/features/auto-responses/
"""
settings = self.bot.settings[ctx.guild]
prefix = re.escape(settings.command_prefix)
match = re.match(f'{prefix}set (.+?)::(.+)', ctx.message.content,
re.IGNORECASE)
if match:
try:
resp = await self.responses[ctx.guild.id].new_response(
match[1], match[2], ctx.guild, ctx.author)
except TriggerCollisionException as e:
msg = "❌ sorry that trigger collides with the following auto responses:\n"
msg += '\n'.join([f"`{r}`" for r in e.conflicts[:4]])
if len(e.conflicts) > 4:
msg += f"\n_...{len(e.conflicts) - 4} more not shown_"
await ctx.send(msg)
except LongResponseException:
await ctx.send(
f"❌ that response is too long :confused: max length is "
f"{settings.responses_response_length} characters")
except ShortTriggerException:
await ctx.send(
f"❌ please make your trigger longer than {settings.responses_trigger_length} characters"
)
except UserLimitException:
await ctx.send(
f"❌ looks like you've already used all your auto responses "
f"in this server ({settings.responses_limit}), try deleting some"
)
except ParseError as e:
await ctx.send(f"❌ unable to parse that response: `{e}`")
except NotParseable as e:
await ctx.send(f"❌ unable to parse your trigger: `{e}`")
except DisabledException as e:
await ctx.send(
f"❌ {e} disabled, you can enable in `{settings.command_prefix}settings responses`"
)
except Exception:
logger.exception("")
await ctx.send("❌ unknown error 😵")
else:
await ctx.send(f"✅ `{resp}` _successfully set_")
else:
match = re.match(f'{prefix}set (.+?):(.+)', ctx.message.content,
re.IGNORECASE)
if match:
await ctx.send(
f"❌ **nice brain** use two `::`\n`{prefix}set {match[1]}::{match[2]}`"
)
else:
await ctx.send("❌ use the syntax: `trigger::response`")
def _run(self):
while self.taskQueue.empty() is not True:
try:
oneTask = self.taskQueue.get(block=False)
func = oneTask[0]
args = oneTask[1]
func(args[0], args[1], args[2])
except Exception as E:
logger.exception(E)
def agane(self, trash):
if self.playing_file:
return
if len(self.q) == 0:
coro = self.voice.disconnect()
else:
coro = self.play()
fut = asyncio.run_coroutine_threadsafe(coro, self.bot.loop)
try:
fut.result()
except Exception:
logger.exception('error playing next thing')
async def notify_deletion(self, emoji: discord.Emoji) -> None:
"""send a dm to whomever's emoji we just deleted"""
user = emoji.user
if user is None:
logger.debug("I don't know who created this emoji")
return
try:
await user.send(
f"**Notice:** your emoji has been deleted from {self.guild.name} because it is a duplicate.\n"
f"Type the emoji name as you normally would (`:{emoji.name}:`) if it was cached.\n"
f"emoji: {emoji.url}")
except Exception:
logger.exception('')
async def play_file(self, filepath):
self.playing_file = True
self.stop()
if self.voice is None:
return
# if (self.player and self.player.is_playing()):
# return await self.skip()
try:
self.player = self.voice.create_ffmpeg_player(filepath, after=self.agane, stderr=subprocess.STDOUT)
self.player.start()
except Exception:
logger.exception("can't create new player")
self.playing_file = False
return True
async def get_value(self, ctx, settings):
await ctx.send(self.description)
user_msg = await ctx.bot.wait_for(
'message', check=lambda m: m.author == ctx.author and self.check(m))
try:
value = await self.parse(ctx, user_msg, settings)
except ValueError:
await ctx.send(self.failure_msg)
except Exception:
await ctx.send("Something bad happened... try again?")
logger.exception(f"Caught exception, continuing...")
return
else:
setattr(settings, self.setting, value)
await ctx.send(self.success_msg)
async def cache_guild(self, guild):
'''cache interesting information about all the messages in a guild'''
logger.debug(f"Downloading messages in {len(guild.channels)} channels for '{guild.name}'...")
for channel in guild.text_channels:
try:
await self.cache_channel(channel)
except Forbidden:
logger.warning(f"Insuffcient permissions to download messages from '{guild.name}.{channel.name}'")
except HTTPException as e:
logger.error(f"Caught {e} when downloading '{guild.name}.{channel.name}'")
logger.error("trying again in 10 seconds...")
await asyncio.sleep(10)
try:
await self.cache_channel(channel)
except Exception:
logger.exception("failed to download channel a second time, giving up :(")
async def scan(self, msg):
"""scans a message for cached emoji and, if it finds any, loads the emoji and replaces the message"""
if msg.author.bot:
return
content = msg.content
matches = self.emoji_pattern.finditer(content)
replace = False
did_match = False
for match in matches:
did_match = True
if match['nameonly']:
emoji = self.find_emoji(name=match['nameonly'])
if emoji is not None:
emoji.num_uses += 1
replace = replace if emoji.loaded else True
await self.bump_emoji(emoji)
content = content.replace(f":{emoji.name}:",
emoji.to_discord_str())
else:
emoji = self.find_emoji(d_id=match['id'],
a_id=match['id'],
name=match['name'])
if emoji is not None:
emoji.num_uses += 1
replace = replace if emoji.loaded else True
await self.bump_emoji(emoji)
content = content.replace(f"<:{emoji.name}:{match['id']}>",
emoji.to_discord_str())
if did_match:
await self._update_emojis_db(self.emojis)
if replace and self.settings.manage_emojis:
try:
await send_message_webhook(
msg.channel,
content,
username=msg.author.display_name,
avatar_url=str(msg.author.avatar_url_as(format='png')))
except Exception:
logger.exception(f"Couldn't send message with webhook")
else:
self.bot.deletable_messages.append(msg.id)
await msg.delete()
async def api_entry(self, method_name, *args, **kwargs):
"""Callback method for the rpc server
:param method_name: name of the method to execute
:param *args: args to pass through
:param **kwargs: kwargs to pass through
"""
try:
assert not method_name.startswith('_')
method = getattr(self, method_name)
except (AttributeError, AssertionError):
logger.warning(f"Someone tried to call '{method}' but it doesn't exist (or is private)")
return {"message": "No such method"}, sc.NOT_FOUND_404
try:
return await method(*args, **kwargs)
except Exception as e:
logger.exception(f"caught exception while handling remote request")
return {"message": f"'{e}'"}, sc.INTERNAL_SERVER_ERROR_500
async def quote(ctx, message: discord.Message):
'''Quotes a previous message in a pretty format. Use url or id.'''
utc = message.created_at.replace(tzinfo=timezone('UTC'))
est = utc.astimezone(timezone('US/Eastern'))
em = discord.Embed(title=est.strftime("%Y-%m-%d %I:%M %p"),
description=message.content,
colour=0x42f468)
em.set_author(name=message.author.display_name,
icon_url=message.author.avatar_url)
em.set_footer(text='#' + message.channel.name)
try:
if message.embeds:
em.set_image(url=message.embeds[0].url)
elif message.attachments:
em.set_image(url=message.attachments[0].url)
except (IndexError, KeyError):
logger.exception("tried to attach image, couldn't")
await ctx.channel.send(embed=em)
def login(self, ipaddress, port, user_passwd_pair_list):
try:
conn = pymongo.MongoClient(ipaddress, port)
dbname = conn.list_database_names()
log_success("MongoDB", ipaddress, port, None)
conn.close()
return
except Exception as E:
logger.debug(E)
finally:
pass
for user_passwd_pair in user_passwd_pair_list:
try:
client = pymongo.MongoClient(
host=ipaddress,
port=port,
maxIdleTimeMS=int(self.timeout * 1000),
socketTimeoutMS=int(self.timeout * 1000),
connectTimeoutMS=int(self.timeout * 1000),
serverSelectionTimeoutMS=int(self.timeout * 1000),
waitQueueTimeoutMS=int(self.timeout * 1000),
wTimeoutMS=int(self.timeout * 1000),
socketKeepAlive=False,
connect=False
)
except Exception as E:
logger.exception(E)
logger.debug('ConnectException: {} {} {}'.format(E, ipaddress, port))
return
try:
db = client.admin
db.authenticate(user_passwd_pair[0], user_passwd_pair[1])
log_success("MongoDB", ipaddress, port, user_passwd_pair)
except Exception as E:
logger.debug('AuthenticationException: %s' % E)
continue
finally:
client.close()
pass
async def pool_request(self,
guild_id,
pool_type: str,
entity_id,
fetch=False):
guild = self.bot.get_guild(int(guild_id)) if guild_id else None
try:
if pool_type == PoolType.MEMBER:
return {
'data': await
self.pools.get_member(guild, entity_id, fetch)
}, 200
elif pool_type == PoolType.USER:
return {
'data': await self.pools.get_user(entity_id, fetch)
}, 200
elif pool_type == PoolType.EMOJI:
return {
'data': await self.pools.get_emoji(guild, entity_id, fetch)
}, 200
except Exception:
logger.exception('')
return {'data': {}}, sc.NOT_FOUND_404
async def handle_task(self, method, *args, **kwargs):
try:
return (await (getattr(self, method)(*args, **kwargs)), 200)
except Exception as e:
logger.exception(f"caught: '{e}' while executing '{method}'")
return {'message': f"caught: '{e}' while executing '{method}'"}
async def gulag(self, ctx, comrade: discord.Member):
'''
Starts a vote to move a member to the gulag.
Each vote over the threshold will add additional time.
'''
settings = self.bot.settings[ctx.guild]
filtered = filter(lambda role: role.name == "kulak", ctx.guild.roles)
try:
gulag_role = next(filtered)
gulag_emoji = settings.gulag_emoji
assert gulag_emoji is not None
except Exception:
logger.warning("gulag role/emoji not found")
await ctx.send(
"Please create a role called `kulak` and an emoji called `gulag` to use this feature."
)
return
if comrade == self.bot.user:
await ctx.channel.send(file=discord.File('res/treason.gif'))
comrade = ctx.author
t_end = time.time() + 60 * 30
user_list = []
timer_msg = None
timer_msg_gulag = None
generated = False
msg = await ctx.send(
f"{settings.gulag_threshold} more {gulag_emoji}'s to gulag {comrade.display_name}"
)
await msg.add_reaction(gulag_emoji)
while time.time() < t_end:
user = None
def check(r, u):
return r.message.id == msg.id and str(r.emoji) == gulag_emoji
with suppress(asyncio.TimeoutError):
react, user = await self.bot.wait_for('reaction_add',
timeout=5,
check=check)
if user and user not in user_list and user != self.bot.user:
user_list.append(user)
await msg.edit(
content=
f"{max(0, (settings.gulag_threshold - len(user_list)))} more {gulag_emoji}'s "
f"to gulag {comrade.display_name}")
t_end += int((settings.gulag_severity / 2) * 60)
if len(
user_list
) >= settings.gulag_threshold and gulag_role not in comrade.roles:
try:
logger.debug(comrade.avatar_url)
img = gulaggen.generate(await comrade.avatar_url_as(
format='png', size=1024).read())
generated = True
except Exception:
logger.exception("gulag generator error")
pass
if generated:
await ctx.channel.send(file=discord.File(
img,
filename=f'{self.bot.hoarfrost_gen.generate()}.png'))
else:
await ctx.channel.send(f"gulag'd {comrade.display_name}")
timer_msg = await ctx.channel.send(
f"⏰ {int(settings.gulag_severity * 60)} seconds")
with suppress(AttributeError):
timer_msg_gulag = await (
discord.utils.get(ctx.guild.text_channels,
name='gulag')
).send(
f"⏰ {int(settings.gulag_severity * 60)} seconds, {comrade.display_name}"
)
await comrade.add_roles(gulag_role)
t_end = time.time() + int(60 * settings.gulag_severity)
elif timer_msg or timer_msg_gulag:
await timer_msg.edit(
content=f"⏰ {int(max(0, t_end - time.time()))} seconds")
with suppress(AttributeError):
await timer_msg_gulag.edit(
content=f"⏰ {int(max(0, t_end - time.time()))} seconds,"
f" {comrade.display_name}")
if gulag_role not in comrade.roles:
await msg.edit(
content=f"Vote for {comrade.display_name} failed to pass")
await comrade.remove_roles(gulag_role)
logger.info('ungulag\'d ' + comrade.display_name)
from ftplib import FTP
from bruteforce.password import Password_total
from lib.config import logger, log_success
SSL_FLAG = True
try:
import bmemcached
import pymongo
import pymysql
import redis
from pssh.clients import ParallelSSHClient
from impacket.smbconnection import SMBConnection
except Exception as E:
logger.exception(E)
try:
from bruteforce.rdp_check import check_rdp
import psycopg2
except Exception as E:
SSL_FLAG = False
import gevent
from Crypto.Cipher import DES
from gevent import socket
from gevent.monkey import patch_all
class SSH_login(object):
def __init__(self, timeout=1):
self.timeout = timeout
