def test_db_connection():
connection_success = Connection(dbhost=DBHOST,
dbport=DBPORT,
database=DATABASE,
dbuser=DBUSER,
dbpassword=DBPASSWORD,
create_tables=False).get_connection()
connection_wrong = Connection(dbhost='localhost',
dbport=3306,
database='xyz',
dbuser='******',
dbpassword='******',
create_tables=False).get_connection()
assert connection_success is not None, "The request was not successful. Check credentials, database existence, etc"
assert connection_wrong is None, f"Connection with wrong credentials must be 'None'"
class Miamala:
ctx = user.quick_login("admin", "admin")
meseji = sms.get_sms(ctx, 1, 1, qty=10, unread_preferred=True)
data = Connection()
def save_miamala(self):
"""miamala ilio ingia kwenye account"""
for ujumbe in self.meseji['response']['Messages']['Message']:
if "HaloPesa" in ujumbe["Phone"]:
muamala = ujumbe['Content'].split(' ')
if "Transaction" and "received" in muamala:
try:
self.Transaction_id = muamala[2]
amount = muamala[muamala.index("received") + 1]
phone = muamala[muamala.index('number') + 1]
sender = muamala[muamala.index('from') +
1] + " " + muamala[
muamala.index('from') + 2]
time = muamala[muamala.index('time') + 2]
date = muamala[muamala.index('time') + 1]
query = f"""INSERT INTO watu.miamla (transaction_id,amout,phone,sender,time,date)
values ({self.Transaction_id},{amount},{phone},{sender},{time},{date}) """
except Exception as e:
logging.INFO("Error in muamala")
pass
finally:
self.data.run_query(query)
def watu_details(self):
"""get information of people"""
query = "SELECT * FROM watu.people"
watu = self.data.run_query(query)
return jsonify(watu)
def append(s, clients):
# Insert to table all clients in list
for key in clients:
# Get robot by anchor
r = s.db.query(Robot)\
.join('container')\
.filter(Robot.anchor==key)\
.first()
if not r:
# robot doesn't exist - skip
s.log.critical('Robot {0} does NOT exist'.format(key))
continue
# Create connection row
c = Connection(since=clients[key]['Connected Since'],
vaddress=clients[key]['Virtual Address'],
raddress=clients[key]['Real Address'],
sent=int(clients[key]['Bytes Sent']),
received=int(clients[key]['Bytes Received']),
container=r.container.id,
node=s.nodeid)
# Add new item to session
s.log.info('Append new connection: {0} -> {1}'.format(
c.raddress, c.vaddress))
s.db.add(c)
s.db_changed = True
def get_member_ranking(username):
conn = Connection()
member = conn.query_sql("SELECT * FROM members where username = '******'")
ranked = sorted([(x[0], x[1], find_in_pi(x[2]))
for x in conn.get_pi_members()],
key=lambda tup: tup[2])
if member:
return str(
ranked.index((member[0], member[1], find_in_pi(member[2]))) +
1) + "°: " + member[
1] + ", respectiva posição nos dígitos de π: " + str(
member[2]) + "\n"
else:
generate_member_ranking(username)
member = conn.query_sql("SELECT * FROM members where username = '******'")
ranked = sorted([(x[0], x[1], find_in_pi(x[2]))
for x in conn.get_pi_members()],
key=lambda tup: tup[2])
return str(
ranked.index((member[0], member[1], find_in_pi(member[2]))) +
1) + "°: " + member[
1] + ", respectiva posição nos dígitos de π: " + str(
member[2]) + "\n"
def __init__(self, fb_token=None, fb_id=None, tinder_token=None):
if tinder_token:
self._api = TinderApi(tinder_token=tinder_token)
else:
self._facebook_data = FacebookTools(access_token=fb_token,
fb_id=fb_id)
self._api = TinderApi(self._facebook_data.access_token,
self._facebook_data.facebook_id)
self._db = Connection(Config.DB_IP, Config.DB_PORT)
def get_daily_ranking():
conn = Connection()
msg = ''
ranked = sorted([(x[0], x[1], find_in_pi(x[2]))
for x in conn.get_pi_members()],
key=lambda tup: tup[2])
for rank in ranked:
msg += str(ranked.index(rank) + 1) + "°: " + rank[
1] + ", respectiva posição nos dígitos de π: " + str(
rank[2]) + "\n"
return msg
def __init__(self):
self.API_TOKEN = os.environ["SECRET"]
self.contatinhosSheet = "http://bit.ly/contatosbcc021"
self.githubRepo = "https://github.com/lineuzinho-icmc/lineuzinho"
self.usefulLinks = "Estamos adicionando todo mundo aos poucos. Se puder ajudar a achar o pessoal, passa o link do grupo na descrição!\n\nInscrição na semana de recepção: calouros.icmc.usp.br/\n\nGuia do Bixo: https://bit.ly/3c9mcUG\n\nContatinho de geral: {0}\n\nEnquetes: https://t.me/joinchat/qrJ_MrnHDbE1ZmNh\n\n".format(
self.contatinhosSheet)
self.docsChannel = "https://t.me/docs21"
self.greeter = Greeter()
self.forwarder = Forwarder()
self.beaner = Beaner()
self.conn = Connection()
self.last_pi_call = time.time()
def save(self, author, tipo, genre):
try:
connection = Connection().get_connection()
cursor = connection.cursor()
insert = """INSERT INTO music (name, author, genre) values ('{0}', '{1}', '{2}');""".format(
author, tipo, genre)
cursor.execute(insert)
connection.commit()
except (Exception, psycopg2.DatabaseError) as error:
print("Error", error)
finally:
if connection:
cursor.close()
connection.close()
def new_connection(uid, classId, webhookUrl, db):
webhookId, webhookToken = clean_webhook_url(webhookUrl)
regId, time = Classroom.from_uid(uid, db).register(classId)
con = Connection(
uid=uid,
classId=classId,
webhookId=webhookId,
webhookToken=webhookToken,
registration=regId,
expire=parsetime(time),
)
db.add(con)
def get_posts_from_db(self):
try:
from db import Connection
except ImportError as error:
logging.info(error)
with Connection() as conn:
try:
dtypes = {}
self.posts = pd.read_sql("SELECT * FROM posts",
conn,
parse_dates=['timestamp'])
self.posts = self.posts.convert_dtypes()
logging.info("Retrieved posts from database")
except Exception as e:
logging.error(e + "Please ensure container is up and running.")
def generate_member_ranking(username):
conn = Connection()
#Verify if user is already in db
if [i for i, v in enumerate(conn.get_members()) if v[1] == username]:
num = str(randint(0, 1000))
while find_in_pi(num) == -1:
num = str(randint(0, 1000))
conn.execute_sql("UPDATE members SET pi_rank = " + str(num) +
" WHERE username = '******'")
else:
num = str(randint(0, 1000))
while find_in_pi(num) == -1:
num = str(randint(0, 1000))
conn.execute_sql("INSERT INTO members (username, pi_rank) VALUES ('" +
username + "', " + num + ");")
def put_session(self, session):
ipinfo = get_ip_info(session["ip"])
asn = None
block = None
country = None
if ipinfo:
asn_obj = self.get_asn(ipinfo["asn"])
asn = ipinfo["asn"]
block = ipinfo["ipblock"]
country = ipinfo["country"]
# Calculate "hash"
connhash = ""
for line in session["text_in"].split("\n"):
line = line.strip()
linehash = abs(hash(line)) % 0xFFFF
connhash += struct.pack("!H", linehash)
connhash = connhash.encode("hex")
backend_user = self.session.query(User).filter(
User.username == session["backend_username"]).first()
conn = Connection(ip=session["ip"],
user=session["user"],
date=session["date"],
password=session["pass"],
text_combined=session["text_combined"],
asn_id=asn,
ipblock=block,
country=country,
connhash=connhash,
backend_user_id=backend_user.id)
self.session.add(conn)
self.session.flush()
req_urls = []
for url in session["urls"]:
db_url = self.db.get_url(url).fetchone()
url_id = 0
if db_url == None:
url_ip, url_info = get_url_info(url)
url_asn = None
url_country = None
if url_info:
asn_obj_url = self.get_asn(url_info["asn"])
url_asn = url_info["asn"]
url_country = url_info["country"]
url_id = self.db.put_url(url, session["date"], url_ip, url_asn,
url_country)
req_urls.append(url)
elif db_url["sample"] == None:
req_urls.append(url)
url_id = db_url["id"]
else:
# Sample exists already
# TODO: Check url for oldness
url_id = db_url["id"]
self.db.link_conn_url(conn.id, url_id)
# Find previous connections
# A connection is associated when:
# - same honeypot/user
# - connection happened as long as 120s before
# - same client ip OR same username/password combo
assoc_timediff = 120
previous_conns = (self.session.query(Connection).filter(
Connection.date > (conn.date - assoc_timediff),
or_(
and_(Connection.user == conn.user,
Connection.password == conn.password),
Connection.ip == conn.ip),
Connection.backend_user_id == conn.backend_user_id,
Connection.id != conn.id).all())
for prev in previous_conns:
conn.conns_before.append(prev)
# Check connection against all tags
tags = self.session.query(Tag).all()
conn = self.session.query(Connection).filter(
Connection.id == conn.id).first()
for tag in tags:
json_obj = conn.json(depth=0)
json_obj["text_combined"] = filter_ascii(json_obj["text_combined"])
if simple_eval(tag.code, names=json_obj) == True:
self.db.link_conn_tag(conn.id, tag.id)
return req_urls
async def _get_crypto_token(self):
async with Connection() as connect:
return await connect.fetch(
'''SELECT *
FROM crypto_token
WHERE email='$1' ''', self.email)
import csv
from bson.objectid import ObjectId
from datetime import date
from db import Connection
def find(arr, key, value):
for item in arr:
if item[key] == value:
return item
lists = []
con = Connection()
lists_cusror = con.find_lists({})
for list in lists_cusror:
lists.append(list)
current_date = date.today().strftime('%Y-%m-%d')
to_read = find(lists, 'name', 'To Read')['name']
read = find(lists, 'name', 'Read')['name']
reading = find(lists, 'name', 'Currently Reading')['name']
books = []
print(to_read_id)
print(read_id)
print(reading_id)
with open('/Users/abhishek/Downloads/goodreads_library_export.csv',
def put_session(self, session):
ipinfo = None
asn = None
block = None
country = None
if self.do_ip_to_asn_resolution:
ipinfo = get_ip_info(session["ip"])
if ipinfo:
asn_obj = self.get_asn(ipinfo["asn"])
asn = ipinfo["asn"]
block = ipinfo["ipblock"]
country = ipinfo["country"]
report = {}
if self.vt != None:
if self.web.get_ip_report(session["ip"]) == None:
report = self.vt.query_ip_reports(session["ip"])
ipReport = IpReport(ip=session["ip"],
report=json.dumps(report))
self.session.add(ipReport)
# Calculate "hash"
connhash = ""
for event in session["stream"]:
if event["in"]:
line = event["data"]
line = ''.join(char for char in line
if ord(char) < 128 and ord(char) > 32)
if line != "":
linehash = abs(hash(line)) % 0xFFFF
connhash += struct.pack("!H", linehash)
connhash = connhash.encode("hex")
backend_user = self.session.query(User).filter(
User.username == session["backend_username"]).first()
conn = Connection(ip=session["ip"],
user=session["user"],
date=session["date"],
password=session["pass"],
stream=json.dumps(session["stream"]),
asn_id=asn,
ipblock=block,
country=country,
connhash=connhash,
backend_user_id=backend_user.id)
self.session.add(conn)
self.session.flush()
req_urls = []
set_urls = set(session["urls"])
for url in set_urls:
db_url = self.db.get_url(url).fetchone()
url_id = 0
report = ''
parsed_uri = urlparse(url)
domain = '{uri.netloc}'.format(uri=parsed_uri)
if self.vt != None:
report = self.vt.query_domain_reports(domain)
domainReport = DomainReport(domain=domain,
report=json.dumps(report))
self.session.add(domainReport)
if db_url == None:
url_ip = None
url_asn = None
url_country = None
if self.do_ip_to_asn_resolution:
url_ip, url_info = get_url_info(url)
if url_info:
asn_obj_url = self.get_asn(url_info["asn"])
url_asn = url_info["asn"]
url_country = url_info["country"]
url_id = self.db.put_url(url, session["date"], url_ip, url_asn,
url_country)
req_urls.append(url)
elif db_url["sample"] == None:
req_urls.append(url)
url_id = db_url["id"]
else:
# Sample exists already
# TODO: Check url for oldness
url_id = db_url["id"]
self.db.link_conn_url(conn.id, url_id)
# Find previous connections
# A connection is associated when:
# - same honeypot/user
# - connection happened as long as 120s before
# - same client ip OR same username/password combo
assoc_timediff = 120
previous_conns = (self.session.query(Connection).filter(
Connection.date > (conn.date - assoc_timediff),
or_(
and_(Connection.user == conn.user,
Connection.password == conn.password),
Connection.ip == conn.ip),
Connection.backend_user_id == conn.backend_user_id,
Connection.id != conn.id).all())
for prev in previous_conns:
conn.conns_before.append(prev)
# Check connection against all tags
tags = self.session.query(Tag).all()
conn = self.session.query(Connection).filter(
Connection.id == conn.id).first()
for tag in tags:
json_obj = conn.json(depth=0)
json_obj["text_combined"] = filter_ascii(json_obj["text_combined"])
if simple_eval(tag.code, names=json_obj) == True:
self.db.link_conn_tag(conn.id, tag.id)
return req_urls
#!//usr/bin/python3.6
import hashlib
import random
import requests
import json
import threading
from OpenSSL import SSL
from flask import *
from flask_cors import CORS
from db import Connection
from bs4 import BeautifulSoup
import urllib.request as urllib2
import re
from smmbget import get_level_info, check_valid_level, write_level_info, check_level_duplicate
c = Connection()
c.connect()
members = c.fetch("members")
if not members:
c.create("members", {"username": None, "password": None, "salt": None, "admin": 0})
pepper = "efoijxewioufhaewprofwefz;dorfgjlakesdf;;yesIhitmyheadonmykeyboard"
app = Flask(__name__, template_folder='templates', static_folder='templates/static')
CORS(app)
def set_admin(username):
c.connect()
members = c.fetch("members")
members.add({"admin":1}, {"username":username})
return True
"channels": {
"feed": 762952918848503859,
"debug": 764641152682033172
}
}]
CACHE = {}
LEVELER = None
FROZEN_USERS = []
IGNORE_ROLES = ["@everyone", "Muted"]
# load_dotenv()
# TOKEN = os.getenv('DISCORD_TOKEN')
TOKEN = os.environ["DISCORD_TOKEN"]
conn = Connection()
c = conn.cursor
routes = Routes(conn, c)
def is_moderator(ctx):
mod_roles = CACHE[ctx.guild.id]["roles"]["Moderators"]
admin_roles = CACHE[ctx.guild.id]["roles"]["Administrators"]
valid_roles = mod_roles + admin_roles
if any(r in ctx.author.roles for r in valid_roles):
return True
return False
def put_session(self, session):
ipinfo = None
asn = None
block = None
country = None
network_id = None
if self.do_ip_to_asn_resolution:
ipinfo = get_ip_info(session["ip"])
if ipinfo:
asn_obj = self.get_asn(ipinfo["asn"])
asn = ipinfo["asn"]
block = ipinfo["ipblock"]
country = ipinfo["country"]
# Calculate "hash"
connhash = ""
for event in session["stream"]:
if event["in"]:
line = event["data"]
line = ''.join(char for char in line
if ord(char) < 128 and ord(char) > 32)
if line != "":
linehash = abs(hash(line)) % 0xFFFF
connhash += struct.pack("!H", linehash)
connhash = connhash.encode("hex")
backend_user = self.session.query(User).filter(
User.username == session["backend_username"]).first()
conn = Connection(ip=session["ip"],
user=session["user"],
date=session["date"],
password=session["pass"],
stream=json.dumps(session["stream"]),
asn_id=asn,
ipblock=block,
country=country,
connhash=connhash,
backend_user_id=backend_user.id)
self.session.add(conn)
self.session.flush() # to get id
samples = []
urls = []
for sample_json in session["samples"]:
sample, url = self.create_url_sample(sample_json)
if network_id == None and sample.network_id != None:
network_id = sample.network_id
if network_id == None and url.network_id != None:
network_id = url.network_id
conn.urls.append(url)
samples.append(sample)
urls.append(url)
# Find previous connections
# A connection is associated when:
# - same honeypot/user
# - connection happened as long as 120s before
# - same client ip OR same username/password combo
assoc_timediff = 120
previous_conns = (self.session.query(Connection).filter(
Connection.date > (conn.date - assoc_timediff),
or_(
and_(Connection.user == conn.user,
Connection.password == conn.password),
Connection.ip == conn.ip),
Connection.backend_user_id == conn.backend_user_id,
Connection.id != conn.id).all())
for prev in previous_conns:
if network_id == None and prev.network_id != None:
network_id = prev.network_id
conn.conns_before.append(prev)
# Check connection against all tags
tags = self.session.query(Tag).all()
for tag in tags:
json_obj = conn.json(depth=0)
json_obj["text_combined"] = filter_ascii(json_obj["text_combined"])
if simple_eval(tag.code, names=json_obj) == True:
self.db.link_conn_tag(conn.id, tag.id)
# Only create new networks for connections with urls or associtaed conns,
# to prevent the creation of thousands of networks
# NOTE: only conns with network == NULL will get their network updated
# later so whe should only create a network where we cannot easily
# change it later
if (len(conn.urls) > 0
or len(previous_conns) > 0) and network_id == None:
network_id = self.create_network().id
# Update network on self
conn.network_id = network_id
# Update network on all added Urls
for url in urls:
if url.network_id == None:
url.network_id = network_id
# Update network on all added Samples
for sample in samples:
if sample.network_id == None:
sample.network_id = network_id
# Update network on all previous connections withut one
if network_id != None:
for prev in previous_conns:
if prev.network_id == None:
prev.network_id = network_id
self.session.flush()
return []
def main():
the_date = (datetime.datetime.now() +
datetime.timedelta(days=-1)).strftime("%Y-%m-%d")
if len(sys.argv) > 1:
the_date = sys.argv[1]
log_file = "./login_%s.txt" % (the_date)
insertSql = "insert into bd_action.login_action(q_date,q_time,q_ip,q_uid,q_login_type,q_dev_type,q_result_code,q_channel,q_dev_imei,q_dev_model,q_net,q_app_ver,q_sys_version,q_mobile,q_login_uid,q_third_type,q_third_id,q_opt_duration) values(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);"
delSql = "delete from bd_action.login_action where q_date='%s'" % (
the_date)
conn = Connection(using="bd")
conn.execute(delSql)
'''
filePath = './big.txt'
for chunk in read_in_chunks(filePath):
print chunk
'''
params = []
for line in open(log_file):
log_str = line.strip()
log = json.loads(line)
param = log.get("q_req_param", "{}")
req_data = None
if isinstance(param.get("data", [{}])[0], dict) == False:
req_data = json.loads(param.get("data", [{}])[0])
else:
req_data = param.get("data", [{}])[0]
result = None
if isinstance(log.get("q_opt_result"), dict) == False:
result = json.loads(log.get("q_opt_result"))
else:
result = log.get("q_opt_result")
result_data = result.get("data", {})
if req_data.get("openid", "").find("Testyaliceshi") <> -1:
continue
if req_data.get("isTest", 0) == 1:
continue
q_time = log.get("q_opt_time", "0")
if str(q_time).find(":") == -1:
q_time = time.strftime(
'%Y-%m-%d %H:%M:%S',
time.localtime(string.atof(log.get("q_opt_time", "0")) / 1000))
resultArr = [
the_date, q_time,
log.get("q_ip", "").split(",", -1)[0],
log.get("q_uid", ""),
log.get("q_action", ""),
log.get("q_dev_type", ""),
result.get("code", ""),
log.get("q_channel", ""),
log.get("q_dev_imei", ""),
log.get("q_dev_model", ""),
log.get("q_net", ""),
log.get("q_app_ver", ""),
log.get("q_sys_version", ""),
req_data.get("mobile", ""),
result_data.get("userId", ""),
req_data.get("thirdType", ""),
req_data.get("openid", ""),
log.get("q_opt_duration", "0")
]
params.append(resultArr)
#conn.execute(insertSql,*tuple(resultArr))
try:
conn.executemany(insertSql, params)
except Exception, e:
print traceback.format_exc()
print line
import threading
from water import Water
from communication import Communication
from db import Connection
from sensoren import Sensoren
import time
from apiMain import start
#com = Communication("RPI", "192.168.2.156
com = Communication("RPI", "0.0.0.0")
sensoren = Sensoren(pinRain=22, pinVent1=17, pinVent2=27)
water = Water(com, sensoren)
db = Connection(host="localhost",
user="******",
password="******",
database="sensor_data")
t_com = threading.Thread(target=com.server)
t_sensoren = threading.Thread(target=sensoren.update_data)
t_water = threading.Thread(target=water.main)
t_api = threading.Thread(target=start)
if __name__ == '__main__':
print("Starting")
t_com.start()
t_sensoren.start()
t_water.start()
t_api.start()
while True:
def open_spider(self, spider):
self.conn = Connection(using="bd")
async def _create_crypto_token(self):
async with Connection() as connect:
return await connect.execute(
'''INSERT INTO crypto_token(email, private_key)
VALUES('$1', '$2') ''', self.email, self.key)
def generate_daily_ranking():
conn = Connection()
for user in conn.get_usernames():
generate_member_ranking(user)
async def _update_key(self):
async with Connection() as connect:
return await connect.execute(
'''UPDATE crypto_token
SET private_key='$1'
WHERE email='$2' ''', self.key, self.email)
def put_session(self, session):
connhash = self.calc_connhash(session["stream"]).encode("hex")
backend_user = self.session.query(User).filter(
User.username == session["backend_username"]).first()
conn = Connection(ip=session["ip"],
user=session["user"],
date=session["date"],
password=session["pass"],
stream=json.dumps(session["stream"]),
connhash=connhash,
backend_user_id=backend_user.id)
conn.user = filter_ascii(conn.user)
conn.password = filter_ascii(conn.password)
if self.do_ip_to_asn_resolution:
range = self.get_ip_range(conn.ip)
if range:
conn.country = range.country
conn.city = range.city
conn.lat = range.latitude
conn.lon = range.longitude
conn.asn = range.asn
self.session.add(conn)
self.session.flush() # to get id
network_id = None
samples = []
urls = []
for sample_json in session["samples"]:
# Ignore junk - may clean up the db a bit
if sample_json["length"] < 2000:
continue
sample, url = self.create_url_sample(sample_json)
if sample:
if network_id == None and sample.network_id != None:
network_id = sample.network_id
samples.append(sample)
if url:
if network_id == None and url.network_id != None:
network_id = url.network_id
conn.urls.append(url)
urls.append(url)
# Find previous connections
# A connection is associated when:
# - same honeypot/user
# - connection happened as long as 120s before
# - same client ip OR same username/password combo
assoc_timediff = 120
assoc_timediff_sameip = 3600
previous_conns = (self.session.query(Connection).filter(
or_(
and_(Connection.date > (conn.date - assoc_timediff),
Connection.user == conn.user,
Connection.password == conn.password),
and_(Connection.date > (conn.date - assoc_timediff_sameip),
Connection.ip == conn.ip)),
Connection.backend_user_id == conn.backend_user_id,
Connection.id != conn.id).all())
for prev in previous_conns:
if network_id == None and prev.network_id != None:
network_id = prev.network_id
conn.conns_before.append(prev)
# Check connection against all tags
tags = self.session.query(Tag).all()
for tag in tags:
json_obj = conn.json(depth=0)
json_obj["text_combined"] = filter_ascii(json_obj["text_combined"])
if simple_eval(tag.code, names=json_obj) == True:
self.db.link_conn_tag(conn.id, tag.id)
# Only create new networks for connections with urls or associtaed conns,
# to prevent the creation of thousands of networks
# NOTE: only conns with network == NULL will get their network updated
# later so whe should only create a network where we cannot easily
# change it later
haslogin = conn.user != None and conn.user != ""
if (len(conn.urls) > 0 or
len(previous_conns) > 0) and network_id == None and haslogin:
print(" --- create network --- ")
network_id = self.create_network().id
# Update network on self
conn.network_id = network_id
# Update network on all added Urls
for url in urls:
if url.network_id == None:
url.network_id = network_id
# Update network on all added Samples
for sample in samples:
if sample.network_id == None:
sample.network_id = network_id
# Update network on all previous connections withut one
if network_id != None:
for prev in previous_conns:
if prev.network_id == None:
prev.network_id = network_id
# Update number of first conns on network
if len(prev.conns_before) == 0:
conn.network.nb_firstconns += 1
self.session.flush()
# Check for Malware type
# only if our network exists AND has no malware associated
if conn.network != None and conn.network.malware == None:
# Find connections with similar connhash
similar_conns = (self.session.query(Connection).filter(
func.length(Connection.connhash) == len(connhash)).all())
min_sim = 2
min_conn = None
for similar in similar_conns:
if similar.network_id != None:
c1 = connhash.decode("hex")
c2 = similar.connhash.decode("hex")
sim = self.calc_connhash_similiarity(c1, c2)
if sim < min_sim and similar.network.malware != None:
min_sim = sim
min_conn = similar
# 0.9: 90% or more words in session are equal
# think this is probably the same kind of malware
# doesn't need to be the same botnet though!
if min_sim < 0.9:
conn.network.malware = min_conn.network.malware
else:
conn.network.malware = Malware()
conn.network.malware.name = random.choice(ANIMAL_NAMES)
self.session.add(conn.network.malware)
self.session.flush()
# Update network number of first connections
if len(previous_conns) == 0 and conn.network_id != None:
conn.network.nb_firstconns += 1
return conn.json(depth=1)
## Primary Author: Mayank Mohindra <github.com/mayankmtg>
##
## Description: Main file. Contains logic to handle all commands and start the bot
##
import discord
from discord.ext import commands
from search import perform_search
from config import Config
from cache import save_search_query, find_search_history
from db import Connection
from error import ErrorMessage
Config.load()
client = discord.Client()
conn = Connection(Config.DATABASE)
# bot starts
@client.event
async def on_ready():
print("bot is running")
# bot receives any messages
@client.event
async def on_message(command):
# Ignore string from self
if command.author == client.user:
return
