import json

import multiprocessing

import os

import pathlib

import random

import re

import socket

import string

from getpass import getpass

import botocore

import argparse

import docker

import mongoengine

from flask import Flask

from flask_bcrypt import Bcrypt

from flask_bcrypt import generate_password_hash

from flask_jwt_extended import JWTManager

from termcolor import colored

from waitress import serve

from core.Listeners.WebSocket.server import start_websocket_listener

from core.database.db import initialize_db

from core.database.models import Cosmonaut

from core.database.models import WebsocketListener

from core.models.AWSCredentials import awscredentials_blueprint

from core.models.AWSIAM import awsusers_blueprint

from core.models.AZURECredentials import azurecredentials_blueprint

from core.models.ClientCommands import clientcommands_blueprint

from core.models.Cosmonaut import cosmonaut_blueprint

from core.models.DigitalOceanCredentials import digitaloceancredentials_blueprint

from core.models.Domains import domains_blueprint

from core.models.Listeners import listener_blueprint

from core.models.Modules import module_blueprint

from core.models.AWSS3Buckets import awsbuckets_blueprint

parser = argparse.ArgumentParser(description='------ Nebula Teamserver Options ------')

parser.add_argument('-ap', '--apiPort', type=int, help='The API Server Port. (Default: 5000)', default=5000)

parser.add_argument('-dH', '--databaseHost', type=str, help='The MongoDB Database Server Host. (Default: localhost)', default='localhost')

parser.add_argument('-dP', '--databasePort', type=int, help='The MongoDB Database Server Port. (Default: 27017)', default=27017)

parser.add_argument('-dn', '--databaseName', type=str, help='The MongoDB Database Name. (Required)')

parser.add_argument('-du', '--databaseUser', type=str, help='The MongoDB Database User Name.')

parser.add_argument('-dp', '--databasePassword', type=str, help='The MongoDB Database Password.')

parser.add_argument('-p', '--password', type=str, help='The password for user \'cosmonaut\'. (Required)')

parser.add_argument('-y', '--yes', action="store_true", help='If this is set, the check for the database port will be skipped.')

args = parser.parse_args()

IPv4_REGEX = "^[0-9]{1,3}[.]{1}[0-9]{1,3}[.]{1}[0-9]{1,3}[.]{1}[0-9]{1,3}$"

IPv6_REGEX = "^([0-9a-fA-F]{1,4}[:]{0,2}){1,8}$"

if not args.databaseName:

print("Provide DB Name using -dn (database name)")

exit()

if args.password is not None:

password = args.password

else:

password = getpass("Password: ")

while password == "":

password = getpass("Password: ")

host = args.databaseHost

port = str(args.databasePort)

database = args.databaseName

if args.databaseUser is not None:

databaseUser = args.databaseUser

else:

databaseUser = None

if args.databasePassword is not None:

databasePassword = args.databasePassword

else:

databasePassword = None

all_count = 0

show = [

]

nr_of_modules = {

}

for module in show:

module_count = 0

arr = os.listdir(f"{pathlib.Path(__file__).parent.resolve()}/core/module/" + module)

for x in arr:

if "__" in x:

continue

elif ".git" in x:

continue

else:

module_count += 1

all_count += 1

if module_count == 0:

nr_of_modules[module] = "0"

else:

nr_of_modules[module] = module_count

nr_of_cloud_modules = {

}

clouds = [

]

for cloud in clouds:

module_count = 0

for module in show:

arr = os.listdir(f"{pathlib.Path(__file__).parent.resolve()}/core/module/{module}")

for x in arr:

if "__" in x:

continue

elif ".git" in x:

continue

else:

if x.split("_")[0] == cloud:

module_count += 1

nr_of_cloud_modules[cloud] = module_count

input_text = colored('------------------------------------------------------------\n', "green")

input_text += colored(''' _ _ _ _

''', 'blue')

input_text += (colored('-------------------------------------------------------------\n', "green"))

input_text += ("{} aws\t\t{} gcp\t\t{} azure\t\t{} office365\n".format(nr_of_cloud_modules['aws'], nr_of_cloud_modules['gcp'],

nr_of_cloud_modules['azure'], nr_of_cloud_modules['o365']))

input_text += (

"{} docker\t{} kubernetes\t{} misc\t\t{} azuread\n".format(nr_of_cloud_modules['docker'], nr_of_cloud_modules['kube'],

nr_of_cloud_modules['misc'],

nr_of_cloud_modules['azuread']))

input_text += (

"{} digitalocean\n".format(nr_of_cloud_modules['digitalocean']))

input_text += (colored("-------------------------------------------------------------\n", "green"))

input_text += ("{} modules\t{} cleanup\t\t{} detection\n".format(all_count, nr_of_modules['cleanup'], nr_of_modules['detection']))

input_text += ("{} enum\t\t{} exploit\t\t{} persistence\n".format(nr_of_modules['enum'], nr_of_modules['exploit'],

nr_of_modules['persistence']))

input_text += ("{} listeners\t{} lateral movement\t{} detection bypass\n".format(nr_of_modules['listeners'],

nr_of_modules['lateralmovement'],

nr_of_modules['detectionbypass']))

input_text += ("{} privesc\t{} reconnaissance\t{} stager\t{}postexploitation\n".format(nr_of_modules['privesc'], nr_of_modules['reconnaissance'],

nr_of_modules['stager'], nr_of_modules['postexploitation']))

input_text += ("{} misc\n".format(nr_of_modules['misc']))

print (input_text)

app = Flask(__name__)

bcrypt = Bcrypt(app)

jwt = JWTManager(app)

jwt_token = ''.join(random.choice(string.ascii_lowercase + string.ascii_uppercase + string.digits) for _ in range(32))

app.config['JWT_SECRET_KEY'] = jwt_token

sessionfile = f"{botocore.__path__[0]}/session.py"

useragentfile = f"{botocore.__path__[0]}/.user-agent"

with open(sessionfile, "r") as botocoresessionfile:

botocorecheck = 0

botocoresessionfilelines = botocoresessionfile.readlines()

for line in botocoresessionfilelines:

if 'site-packages/botocore/.user-agent' in line:

botocorecheck = 1

if botocorecheck == 0:

with open(sessionfile, "w") as botocoresessiontemp:

for bline in botocoresessionfilelines:

if 'return base' in bline:

botocoresessiontemp.write('\t\timport sys\n'.expandtabs(4))

botocoresessiontemp.write(f'\t\tif os.path.exists(f"{useragentfile}"):\n'.expandtabs(4))

botocoresessiontemp.write(f'\t\t\twith open(f"{useragentfile}") as uafile:\n'.expandtabs(4))

botocoresessiontemp.write('\t\t\t\tbase = uafile.read().replace("\\n", "").strip()\n'.expandtabs(4))

botocoresessiontemp.write('\n')

botocoresessiontemp.write(bline)

else:

botocoresessiontemp.write(bline)

try:

#a_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

#location = (host, port)

#result_of_check = a_socket.connect_ex(location)

result_of_check = 0

if result_of_check == 0 and not args.yes:

mongo_instance_verify = input(colored("[*] Port is busy. Is a MongoDB instance running there? [y/N] ", "red"))

if not mongo_instance_verify.strip().replace("\n", "") == 'y' and not mongo_instance_verify.strip().replace(

"\n", "") == 'Y':

print(colored("[*] Choose another port or stop the other service!", "red"))

exit()

else:

'''

workspace_directory = "/home/testdocker/datafolder"

if not os.path.exists("{}/workspaces/".format(os.getcwd())):

os.mkdir("{}/workspaces/".format(os.getcwd()))

if not os. path.exists("./workspaces/{}".format(database)):

os.mkdir("{}/workspaces/{}".format(os.getcwd(), database))

'''

if databaseUser is not None:

if re.match(IPv4_REGEX, host) or re.match(IPv6_REGEX, host):

app.config['MONGODB_SETTINGS'] = {

'host': f'mongodb://{databaseUser}:{databasePassword}@{host}:{port}/{database}'

#'host': 'mongodb://{0}:{1},{0}:{2},{0}:{3}/{4}?replicaSet=mongodb-replicaset'.format(host, port, port+1, port+2, database)

}

else:

app.config['MONGODB_SETTINGS'] = {

'host': f'mongodb+srv://{databaseUser}:{databasePassword}@{host}/{database}'

#'host': 'mongodb://{0}:{1},{0}:{2},{0}:{3}/{4}?replicaSet=mongodb-replicaset'.format(host, port, port+1, port+2, database)

}

else:

if re.match(IPv4_REGEX, host) or re.match(IPv6_REGEX, host):

app.config['MONGODB_SETTINGS'] = {

'host': f'mongodb://{host}:{port}/{database}'

# 'host': 'mongodb://{0}:{1},{0}:{2},{0}:{3}/{4}?replicaSet=mongodb-replicaset'.format(host, port, port+1, port+2, database)

}

else:

app.config['MONGODB_SETTINGS'] = {

'host': f'mongodb+srv://{host}/{database}'

# 'host': 'mongodb://{0}:{1},{0}:{2},{0}:{3}/{4}?replicaSet=mongodb-replicaset'.format(host, port, port+1, port+2, database)

}

#app.config['MONGODB_DB'] = database

#app.config['MONGODB_HOST'] = host

#app.config['MONGODB_PORT'] = port

#app.config['MONGODB_CONNECT'] = False

print(colored('------------------------------------------------------------', "green"))

print("{} '{}'".format(

colored("[*] JWT Secret Key set to:", "green"),

colored(jwt_token, "blue")

))

print("{} '{}:{}'".format(

colored("[*] Database Server set to:", "green"),

colored(host, "blue"),

colored(port, "blue")

))

print("{} '{}'".format(

colored("[*] Database set to:", "green"),

colored(database, "blue")

))

# I am not using these on Nebula. So it's not an information disclosure. It's just sth I plan to use latter.

#app.config['MONGODB_USERNAME'] = 'user'

#app.config['MONGODB_PASSWORD'] = 'pass'

initialize_db(app)

try:

body = {

"cosmonaut_name": "cosmonaut",

"cosmonaut_pass": password

}

cosmonaut = Cosmonaut(**body)

cosmonaut.hash_password()

cosmonaut.save()

except mongoengine.errors.NotUniqueError as ex:

cosmonaut = Cosmonaut.objects.get(cosmonaut_name=body['cosmonaut_name'])

body['cosmonaut_pass'] = generate_password_hash(password).decode('utf8')

cosmonaut.update(**body)

#import socket

sIP = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

sIP.connect(("8.8.8.8", 80))

print('{}{}{}'.format(

colored("[*] Teamserver IP address is '", "green"),

colored(sIP.getsockname()[0], "blue"),

colored("'", "green"))

)

sIP.close()

print('{}{}{}'.format(

colored("[*] User '", "green"),

colored("cosmonaut", "blue"),

colored("' was created!", "green")

)

)

app.register_blueprint(listener_blueprint)

app.register_blueprint(cosmonaut_blueprint)

app.register_blueprint(module_blueprint)

app.register_blueprint(awscredentials_blueprint)

app.register_blueprint(awsusers_blueprint)

app.register_blueprint(azurecredentials_blueprint)

app.register_blueprint(digitaloceancredentials_blueprint)

app.register_blueprint(domains_blueprint)

app.register_blueprint(clientcommands_blueprint)

app.register_blueprint(awsbuckets_blueprint)

except SystemExit:

exit()

except docker.errors.DockerException as ex:

print(colored("[*] Please start the docker service. (service docker start)", "red"))

exit()

except Exception as e:

if e == None or e == "":

exit()

else:

print(colored("[*] {}".format(e), "red"))

exit()

def startWebsocketListeners():

exit()

if __name__ == "__main__":

apihost = "0.0.0.0"

apiport = args.apiPort

print("{} '{}:{}'".format(

colored("[*] API Server set to:", "green"),

colored(apihost, "blue"),

colored(apiport, "blue")

))

print(colored('------------------------------------------------------------', "green"))

startWebsocketListeners()

serve(app, host=apihost, port=apiport)