def __init__(self, run_args, debug=False, keep_alive=75, **kwargs):

self.dorks = []

self.run_args = run_args

self.sroute = StaticRoute(

name=None, prefix='/',

directory='/opt/snare/pages/{}'.format(run_args.page_dir)

)

super().__init__(debug=debug, keep_alive=keep_alive, access_log=None, **kwargs)

@asyncio.coroutine

def get_dorks(self):

dorks = None

try:

with aiohttp.Timeout(10.0):

with aiohttp.ClientSession() as session:

r = yield from session.get(

'http://{0}:8090/dorks'.format(self.run_args.tanner)

)

try:

dorks = yield from r.json()

except json.decoder.JSONDecodeError as e:

print(e)

finally:

r.release()

except:

print('Dorks timeout')

return dorks['response']['dorks'] if dorks else []

@asyncio.coroutine

def submit_slurp(self, data):

try:

with aiohttp.Timeout(10.0):

with aiohttp.ClientSession(connector=aiohttp.TCPConnector(verify_ssl=False)) as session:

r = yield from session.post(

'https://{0}:8080/api?auth={1}&chan=snare_test&msg={2}'.format(

self.run_args.slurp_host, self.run_args.slurp_auth, data

), data=json.dumps(data)

)

assert r.status == 200

r.close()

except Exception as e:

print(e)

def create_data(self, request, response_status):

data = dict(

method=None,

path=None,

headers=None,

uuid=snare_uuid.decode('utf-8'),

peer=None,

status=response_status

)

if self.transport:

peer = dict(

ip=self.transport.get_extra_info('peername')[0],

port=self.transport.get_extra_info('peername')[1]

)

data['peer'] = peer

if request:

header = {key: value for (key, value) in request.headers.items()}

data['method'] = request.method

data['headers'] = header

data['path'] = request.path

if ('Cookie' in header):

data['cookies'] = {cookie.split('=')[0]: cookie.split('=')[1] for cookie in header['Cookie'].split('; ')}

return data

@asyncio.coroutine

def submit_data(self, data):

event_result = None

try:

with aiohttp.Timeout(10.0):

with aiohttp.ClientSession() as session:

r = yield from session.post(

'http://{0}:8090/event'.format(self.run_args.tanner), data=json.dumps(data)

)

try:

event_result = yield from r.json()

except json.decoder.JSONDecodeError as e:

print(e, data)

finally:

r.release()

except Exception as e:

raise e

return event_result

@asyncio.coroutine

def handle_html_content(self, content):

soup = BeautifulSoup(content, 'html.parser')

for p_elem in soup.find_all('p'):

if p_elem.findChildren():

continue

css = None

if 'style' in p_elem.attrs:

css = cssutils.parseStyle(p_elem.attrs['style'])

text_list = p_elem.text.split()

p_new = soup.new_tag('p', style=css.cssText if css else None)

for idx, word in enumerate(text_list):

# Fetch dorks if required

if len(self.dorks) <= 0:

self.dorks = yield from self.get_dorks()

word += ' '

if idx % 5 == 0:

a_tag = soup.new_tag(

'a',

href=self.dorks.pop(),

style='color:{color};text-decoration:none;cursor:text;'.format(

color=css.color if css and 'color' in css.keys() else '#000000'

)

)

a_tag.string = word

p_new.append(a_tag)

else:

p_new.append(soup.new_string(word))

p_elem.replace_with(p_new)

content = soup.encode('utf-8')

return content

@asyncio.coroutine

def handle_request(self, request, payload):

print('Request path: {0}'.format(request.path))

data = self.create_data(request, 200)

if request.method == 'POST':

post_data = yield from payload.read()

post_data = MultiDict(parse_qsl(post_data.decode('utf-8')))

print('POST data:')

for key, val in post_data.items():

print('\t- {0}: {1}'.format(key, val))

data['post_data'] = dict(post_data)

# Submit the event to the TANNER service

event_result = yield from self.submit_data(data)

# Log the event to slurp service if enabled

if self.run_args.slurp_enabled:

yield from self.submit_slurp(request.path)

response = aiohttp.Response(

self.writer, status=200, http_version=request.version

)

content_type = None

mimetypes.add_type('text/html','.php')

mimetypes.add_type('text/html', '.aspx')

base_path = os.path.join('/opt/snare/pages', self.run_args.page_dir)

if event_result is not None and ('payload' in event_result['response']['message']['detection'] and event_result['response']['message']['detection']['payload'] is not None):

payload_content = event_result['response']['message']['detection']['payload']

if type(payload_content) == dict:

if payload_content['page'].startswith('/'):

payload_content['page'] = payload_content['page'][1:]

page_path = os.path.join(base_path, payload_content['page'])

content = '<html><body></body></html>'

if os.path.exists(page_path):

content_type = mimetypes.guess_type(page_path)[0]

with open(page_path, encoding='utf-8') as p:

content = p.read()

soup = BeautifulSoup(content, 'html.parser')

script_tag = soup.new_tag('div')

script_tag.append(BeautifulSoup(payload_content['value'], 'html.parser'))

soup.body.append(script_tag)

content = str(soup).encode()

else:

content_type = mimetypes.guess_type(payload_content)[0]

content = payload_content.encode('utf-8')

else:

query = None

if request.path == '/':

parsed_url = self.run_args.index_page

else:

parsed_url = urlparse(unquote(request.path))

if parsed_url.query:

query = '?' + parsed_url.query

parsed_url = parsed_url.path

if parsed_url.startswith('/'):

parsed_url = parsed_url[1:]

path = os.path.normpath(os.path.join(base_path, parsed_url))

if os.path.isfile(path) and path.startswith(base_path):

content_type = mimetypes.guess_type(path)[0]

with open(path, 'rb') as fh:

content = fh.read()

if content_type:

if 'text/html' in content_type:

content = yield from self.handle_html_content(content)

else:

content_type = None

content = None

response = aiohttp.Response(

self.writer, status=404, http_version=request.version

)

response.add_header('Server', self.run_args.server_header)

if 'cookies' in data and 'sess_uuid' in data['cookies']:

previous_sess_uuid = data['cookies']['sess_uuid']

else:

previous_sess_uuid = None

if event_result is not None and ('sess_uuid' in event_result['response']['message']):

cur_sess_id = event_result['response']['message']['sess_uuid']

if previous_sess_uuid is None or not previous_sess_uuid.strip() or previous_sess_uuid != cur_sess_id:

response.add_header('Set-Cookie', 'sess_uuid=' + cur_sess_id)

if not content_type:

response.add_header('Content-Type', 'text/plain')

else:

response.add_header('Content-Type', content_type)

if content:

response.add_header('Content-Length', str(len(content)))

response.send_headers()

if content:

response.write(content)

yield from response.write_eof()

def handle_error(self, status=500, message=None,

payload=None, exc=None, headers=None, reason=None):

super().handle_error(status, message, payload, exc, headers, reason)

data = self.create_data(message, status)

data['error'] = exc

cfg = configparser.ConfigParser()

cfg['WEB-TOOLS'] = dict(google='', bing='')

with open('/opt/snare/snare.cfg', 'w') as configfile:

if os.getuid() != 0:

print('Snare has to be started as root!')

sys.exit(1)

# Create folders

if not os.path.exists('/opt/snare'):

os.mkdir('/opt/snare')

if not os.path.exists('/opt/snare/pages'):

os.mkdir('/opt/snare/pages')

# Write pid to pid file

with open('/opt/snare/snare.pid', 'wb') as pid_fh:

pid_fh.write(str(os.getpid()).encode('utf-8'))

# Config file

if not os.path.exists('/opt/snare/snare.cfg'):

create_initial_config()

# Read or create the sensor id

uuid_file_path = '/opt/snare/snare.uuid'

if os.path.exists(uuid_file_path):

with open(uuid_file_path, 'rb') as uuid_fh:

snare_uuid = uuid_fh.read()

return snare_uuid

else:

with open(uuid_file_path, 'wb') as uuid_fh:

snare_uuid = str(uuid.uuid4()).encode('utf-8')

uuid_fh.write(snare_uuid)

uid_name = 'nobody'

wanted_user = pwd.getpwnam(uid_name)

gid_name = grp.getgrgid(wanted_user.pw_gid).gr_name

wanted_group = grp.getgrnam(gid_name)

os.setgid(wanted_group.gr_gid)

os.setuid(wanted_user.pw_uid)

new_user = pwd.getpwuid(os.getuid())

new_group = grp.getgrgid(os.getgid())

google_content = config['WEB-TOOLS']['google']

bing_content = config['WEB-TOOLS']['bing']

if not google_content and not bing_content:

return

main_page_path = os.path.join('/opt/snare/pages/', page_dir, index_page)

with open(main_page_path) as main:

main_page = main.read()

soup = BeautifulSoup(main_page, 'html.parser')

if (google_content and

soup.find("meta", attrs={"name": "google-site-verification"}) is None):

google_meta = soup.new_tag('meta')

google_meta.attrs['name'] = 'google-site-verification'

google_meta.attrs['content'] = google_content

soup.head.append(google_meta)

if (bing_content and

soup.find("meta", attrs={"name": "msvalidate.01"}) is None):

bing_meta = soup.new_tag('meta')

bing_meta.attrs['name'] = 'msvalidate.01'

bing_meta.attrs['content'] = bing_content

soup.head.append(bing_meta)

html = soup.prettify("utf-8")

with open(main_page_path, "wb") as file:

while True:

repo = git.Repo(os.getcwd())

try:

rem = repo.remote()

res = rem.fetch()

diff_list = res[0].commit.diff(repo.heads.master)

except TimeoutError:

print('timeout fetching the repository version')

else:

if diff_list:

print('you are running an outdated version, SNARE will be updated and restarted')

repo.git.reset('--hard')

repo.heads.master.checkout()

repo.git.clean('-xdf')

repo.remotes.origin.pull()

pip.main(['install', '-r', 'requirements.txt'])

os.execv(sys.executable, [sys.executable, __file__] + sys.argv[1:])

return

else:

print('you are running the latest version')

result = None

timeouts_coeff = {

'M': 60,

'H': 3600,

'D': 86400

}

form = timeout[-1]

if form not in timeouts_coeff.keys():

print('Bad timeout format, default will be used')

parse_timeout('24H')

else:

result = int(timeout[:-1])

result *= timeouts_coeff[form]

vm = VersionManager()

with aiohttp.ClientSession() as client:

req_url = 'http://{}:8090/version'.format(args.tanner)

try:

resp = yield from client.get(req_url)

result = yield from resp.json()

version = result["version"]

vm.check_compatibility(version)

except aiohttp.errors.ClientOSError:

print("Can't connect to tanner host {}".format(req_url))

exit(1)

else: