def __init__(self, config, dumps_folder):
self.config = config
self.dumps_folder = dumps_folder
self.logger = Log(config).get_logger('Main')
connector = SessionManager(config).connector
directconnection = connector.get_direct_session()
self.session = directconnection
self.notmapped = open(self.dumps_folder + '/notmapped.txt', 'w')
self.event_controller = EventController(config, directconnection)
self.attr_def_controller = AttributeDefinitionController(config, directconnection)
self.obj_def_controller = ObjectDefinitionController(config, directconnection)
def_con = ConditionController(config, directconnection)
self.conditions = def_con.get_all_conditions()
def_con = ReferencesController(config, directconnection)
self.ressources = def_con.get_reference_definitions_all()
def_con = IndicatorController(config, directconnection)
self.types = def_con.get_all_types()
self.user_controller = UserController(config, directconnection)
self.group_controller = GroupController(config, directconnection)
self.users = dict()
self.groups = dict()
self.seen_attributes = dict()
self.seen_attr_defs = dict()
self.seen_obj_defs = dict()
def __init__(self, config, session=None):
self.config = config
self.__logger = Log(self.config)
self.session_manager = SessionManager(config, session)
self.user_broker = self.broker_factory(UserBroker)
self.group_broker = self.broker_factory(GroupBroker)
self.obj_def_broker = self.broker_factory(ObjectDefinitionBroker)
self.attr_def_broker = self.broker_factory(AttributeDefinitionBroker)
def __init__(self, config):
self.config = config
self.session_manager = SessionManager(config)
directconnection = self.session_manager.connector.get_direct_session()
self.relation_controller = RelationController(config, directconnection)
self.attribute_definition_controller = AttributeDefinitionController(
config, directconnection)
self.object_definition_controller = ObjectDefinitionController(
config, directconnection)
self.event_controller = EventController(config, directconnection)
self.user_controller = UserController(config, directconnection)
self.reference_controller = ReferencesController(
config, directconnection)
self.conditions_controller = ConditionController(
config, directconnection)
self.verbose = False
# set maintenance user
user_uuid = config.get('ce1sus', 'maintenaceuseruuid', None)
if None:
raise MaintenanceException(
'maintenaceuseruuid was not defined in config')
try:
self.user = self.user_controller.get_user_by_uuid(user_uuid)
except ControllerNothingFoundException:
raise MaintenanceException(
'Cannot find maintenance user with uuid {0}'.format(user_uuid))
except ControllerException as error:
raise MaintenanceException(error)
def __init__(self, config):
self.config = config
self.session_manager = SessionManager(config)
directconnection = self.session_manager.connector.get_direct_session()
self.process_controller = ProcessController(config, directconnection)
self.server_controller = SyncServerController(config, directconnection)
self.misp_converter = MispConverter(config, None, None, None,
directconnection)
dump = config.get('MISPAdapter', 'dump', False)
file_loc = config.get('MISPAdapter', 'file', None)
self.misp_converter.dump = dump
self.misp_converter.file_location = file_loc
self.misp_ctrl = MISPAdapter(config, directconnection)
user_uuid = config.get('ce1sus', 'maintenaceuseruuid', None)
self.user_controller = UserController(config, directconnection)
self.event_controller = EventController(config, directconnection)
self.group_broker = self.user_controller.broker_factory(GroupBroker)
self.mail_controller = MailController(config, directconnection)
self.ce1sus_adapter = Ce1susAdapter(config, directconnection)
if None:
raise SchedulerException(
'maintenaceuseruuid was not defined in config')
try:
self.user = self.user_controller.get_user_by_uuid(user_uuid)
except ControllerNothingFoundException:
raise SchedulerException(
'Cannot find maintenance user with uuid {0}'.format(user_uuid))
except ControllerException as error:
raise SchedulerException(error)
class BasePlugin(object):
def __init__(self, config):
self.conig = config
self.__logger = Log(config)
self.session_manager = SessionManager(config)
@property
def logger(self):
return self.__logger.get_logger(self.__class__.__name__)
def broker_factory(self, clazz):
"""
Instantiates a broker.
Note: In short sets up the broker in a correct manner with all the
required settings
:param clazz: The BrokerClass to be instantiated
:type clazz: Extension of brokerbase
:returns: Instance of a broker
"""
self.logger.debug('Create broker for {0}'.format(clazz))
return self.session_manager.broker_factory(clazz)
registered_list[type_].append(uuid)
except HandlerException:
pass
if __name__ == '__main__':
# want parent of parent directory aka ../../
# setup cherrypy
#
ce1susConfigFile = basePath + 'config/ce1sus.conf'
config = Configuration(ce1susConfigFile)
print "Getting config"
config.get_section('Logger')['log'] = False
print "Creating DB"
session = SessionManager(config)
engine = session.connector.get_engine()
Base.metadata.create_all(engine, checkfirst=True)
print "Populating DB and checking/creating gpg db"
mysql_session = session.connector.get_direct_session()
session = mysql_session
user_ctrl = UserController(config, session)
handler_broker = AttributeHandlerBroker(session)
print "Populate users"
all_users = get_users(config)
users = list()
for user in all_users:
user_ctrl.insert_user(user, False, False, False)
user_ctrl.update_user(user)
users.append(user)
user_ctrl.user_broker.do_commit(False)
help='absolute path to the configuration file')
(options, args) = parser.parse_args()
if options.dump_dest is None:
print 'Destination folder not set'
parser.print_help()
sys.exit(1)
if options.config_file is None:
print 'Configuration file not set'
parser.print_help()
sys.exit(1)
ce1susConfigFile = options.config_file
config = Configuration(ce1susConfigFile)
connector = SessionManager(config).connector
directconnection = connector.get_direct_session()
dest_folder = options.dump_dest
if not exists(dest_folder):
makedirs(dest_folder)
else:
if not isdir(dest_folder):
print '{0} is not a folder'.format(dest_folder)
# create a dump for the events
dump_file(dest_folder + '/events.txt', OldEventBroker, directconnection)
# create a dump for the defintions
dump_file(dest_folder + '/attributedefinitions.txt',
OldAttributeDefinitionsBroker, directconnection)
def __init__(self, config):
self.conig = config
self.__logger = Log(config)
self.session_manager = SessionManager(config)
class BaseController(object):
"""This is the base class for controlles all controllers should extend this
class"""
brokers = dict()
def __init__(self, config, session=None):
self.config = config
self.__logger = Log(self.config)
self.session_manager = SessionManager(config, session)
self.user_broker = self.broker_factory(UserBroker)
self.group_broker = self.broker_factory(GroupBroker)
self.obj_def_broker = self.broker_factory(ObjectDefinitionBroker)
self.attr_def_broker = self.broker_factory(AttributeDefinitionBroker)
def broker_factory(self, clazz):
"""
Instantiates a broker.
Note: In short sets up the broker in a correct manner with all the
required settings
:param clazz: The BrokerClass to be instantiated
:type clazz: Extension of brokerbase
:returns: Instance of a broker
"""
if issubclass(clazz, BrokerBase):
# need to create the broker
instance = self.session_manager.broker_factory(clazz)
return instance
else:
raise ControllerException('Class does not implement BrokerBase')
def get_session(self):
if self.session:
return self.session
else:
return self.session_manager.connector.get_session()
@property
def logger(self):
return self.__logger.get_logger(self.__class__.__name__)
def set_simple_logging(self, instance, user, insert=False):
# set only if not already set :/
if insert:
if not (instance.creator_id or instance.creator):
instance.creator_id = user.identifier
instance.creator = user
if not instance.created_at:
instance.created_at = datetime.utcnow()
if not (instance.modifier_id or instance.modifier):
instance.modifier_id = user.identifier
instance.modifier = user
if not instance.modified_on:
instance.modified_on = datetime.utcnow()
def set_extended_logging(self,
instance,
user,
originating_group,
insert=False):
self.set_simple_logging(instance, user, insert)
if insert:
if not instance.creator_group:
instance.creator_group = user.group
instance.creator_group_id = user.group.identifier
if not instance.originating_group:
instance.originating_group = originating_group
instance.originating_group_id = originating_group.identifier
if not instance.owner_group:
instance.owner_group = originating_group
instance.owner_group_id = originating_group.identifier