def check_config_cron_user(model, request=None):
""" check config user """
# reset stop condition
stop_system_importer_file_csv = False
# check for csv_import_username (after initial migration w/o user defined) - stop immediately
if not model.csv_import_username:
# if function was called from 'system_create_cron' (creating scheduled task)
if request:
# call message
messages.error(request,
'No user for import defined. Check config!')
# get username (needed for logger)
logger_username = str(request.user)
# if function was called from 'system_cron' (scheduled task)
else:
# call message for all users
error_message_cron('No user for import defined. Check config!')
# get main config model
mainconfigmodel = MainConfigModel.objects.get(
main_config_name='MainConfig')
# get cron username from main config (needed for logger if no user was defined in the proper config)
logger_username = mainconfigmodel.cron_username
# call logger
error_logger(logger_username,
' SYSTEM_IMPORTER_FILE_CSV_NO_USER_DEFINED')
# set stop condition
stop_system_importer_file_csv = True
# return stop condition to 'csv.system_create_cron' or 'csv.system_cron'
return stop_system_importer_file_csv
def system_creator_async(request_post, request_user):
""" function to create many systems at once """
# call logger
debug_logger(str(request_user), " SYSTEM_CREATOR_BEGIN")
# exctract lines from systemlist (list results from request object via large text area)
lines = request_post.get('systemlist').splitlines()
# iterate over lines
for line in lines:
# skip emtpy lines
if line == '':
warning_logger(str(request_user), " SYSTEM_CREATOR_ROW_EMPTY")
continue
# check line for length of string
if len(line) > 50:
warning_logger(str(request_user), " SYSTEM_CREATOR_LONG_STRING")
continue
# check for existence of system
system = System.objects.filter(system_name = line)
if system.count() > 0:
# call logger
error_logger(str(request_user), " SYSTEM_CREATOR_SYSTEM_EXISTS " + "system_name:" + line)
# leave this loop because system with this systemname already exists
continue
# create form with request data
form = SystemCreatorForm(request_post)
# create system
if form.is_valid():
# don't save form yet
system = form.save(commit=False)
# set system_name
system.system_name = line
# set auto values
system.system_created_by_user_id = request_user
system.system_modified_by_user_id = request_user
system.system_modify_time = timezone.now()
# save object
system.save()
# save manytomany
form.save_m2m()
# call logger
system.logger(str(request_user), ' SYSTEM_CREATOR_EXECUTED')
# call logger
debug_logger(str(request_user), " SYSTEM_CREATOR_END")
def check_content_file_type(rows, logger_username, request=None):
""" check file for csv respectively some kind of text file """
try:
# try to iterate over rows
for row in rows:
# do nothing
pass
# return True if successful to 'csv_main.system_handler'
return True
# wrong file type
except UnicodeDecodeError:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'Wrong file type for CSV import. Check config or file system!')
# if function was called from 'system_cron'
else:
# call message for all users
error_message_cron(
'Wrong file type for CSV import. Check config or file system!')
# call logger
error_logger(logger_username,
' SYSTEM_IMPORTER_FILE_CSV_WRONG_FILE_TYPE')
# return False if not successful to 'csv_main.system_handler'
return False
# other file errors (e. g. file containing null bytes)
except:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(request,
'File is corrupted. Check config or file system!')
# if function was called from 'system_cron'
else:
# call message for all users
error_message_cron(
'File is corrupted. Check config or file system!')
# call logger
error_logger(logger_username,
' SYSTEM_IMPORTER_FILE_CSV_CORRUPTED_FILE')
# return False if not successful to 'csv_main.system_handler'
return False
def path_check(request):
""" check path from `dfirtrack.config` is existing in filesystem """
# check MARKDOWN_PATH
if not os.path.isdir(markdown_path):
# call logger
error_logger(str(request.user), " MARKDOWN_PATH_NOT_EXISTING")
messages.error(
request,
"The path MARKDOWN_PATH does not exist. Check `dfirtrack.config` or filesystem!"
)
# call logger for consistency
debug_logger(str(request.user), " SYSTEM_MARKDOWN_SYSTEMS_END")
# leave exporter
return False
else:
return True
def config_check(request):
""" check variables in `dfirtrack.config` """
# check MARKDOWN_PATH
if markdown_path == '':
# call logger
error_logger(str(request.user), " MARKDOWN_PATH_VARIABLE_UNDEFINED")
messages.error(
request,
"The variable MARKDOWN_PATH seems to be undefined. Check `dfirtrack.config`!"
)
# call logger for consistency
debug_logger(str(request.user), " SYSTEM_MARKDOWN_SYSTEMS_END")
# leave exporter
return False
else:
return True
def config_check(request):
""" check variables in `dfirtrack.config` """
# check GIRAF_PASS
if giraf_pass == '':
# call logger
error_logger(str(request.user), " GIRAF_PASS_VARIABLE_UNDEFINED")
messages.error(
request,
"The variable GIRAF_PASS seems to be undefined. Check `dfirtrack.config`!"
)
# call logger for consistency
debug_logger(str(request.user), " API_GIRAF_SYSTEMS_END")
# leave importer
return redirect('/systems/')
# check GIRAF_URL
if giraf_url == '':
# call logger
error_logger(str(request.user), " GIRAF_URL_VARIABLE_UNDEFINED")
messages.error(
request,
"The variable GIRAF_URL seems to be undefined. Check `dfirtrack.config`!"
)
# call logger for consistency
debug_logger(str(request.user), " API_GIRAF_SYSTEMS_END")
# leave importer
return redirect('/systems/')
# check GIRAF_USER
if giraf_user == '':
# call logger
error_logger(str(request.user), " GIRAF_USER_VARIABLE_UNDEFINED")
messages.error(
request,
"The variable GIRAF_USER seems to be undefined. Check `dfirtrack.config`!"
)
# call logger for consistency
debug_logger(str(request.user), " API_GIRAF_SYSTEMS_END")
# leave importer
return redirect('/systems/')
def check_content_file_system(model, request=None):
""" check file system """
# reset stop condition
stop_system_importer_file_csv = False
""" set username for logger """
# if function was called from 'system_instant'
if request:
logger_username = str(request.user)
# if function was called from 'system_cron'
else:
logger_username = model.csv_import_username.username # check for existence of user in config was done before
# build csv file path
csv_import_file = model.csv_import_path + '/' + model.csv_import_filename
# CSV import path does not exist - stop immediately
if not os.path.isdir(model.csv_import_path):
# if function was called from 'system_instant'
if request:
# call messsage
messages.error(
request,
'CSV import path does not exist. Check config or file system!')
# if function was called from 'system_cron'
else:
# call message for all users
error_message_cron(
'CSV import path does not exist. Check config or file system!')
# call logger
error_logger(logger_username,
' SYSTEM_IMPORTER_FILE_CSV_PATH_NOT_EXISTING')
# set stop condition
stop_system_importer_file_csv = True
else:
# no read permission for CSV import path - stop immediately
if not os.access(model.csv_import_path, os.R_OK):
# if function was called from 'system_instant'
if request:
# call messsage
messages.error(
request,
'No read permission for CSV import path. Check config or file system!'
)
# if function was called from 'system_cron'
else:
# call message for all users
error_message_cron(
'No read permission for CSV import path. Check config or file system!'
)
# call logger
error_logger(logger_username,
' SYSTEM_IMPORTER_FILE_CSV_PATH_NO_READ_PERMISSION')
# set stop condition
stop_system_importer_file_csv = True
else:
# CSV import file does not exist - stop immediately
if not os.path.isfile(csv_import_file):
# if function was called from 'system_instant'
if request:
# call messsage
messages.error(
request,
'CSV import file does not exist. Check config or provide file!'
)
# if function was called from 'system_cron'
else:
# call message for all users
error_message_cron(
'CSV import file does not exist. Check config or provide file!'
)
# call logger
error_logger(logger_username,
' SYSTEM_IMPORTER_FILE_CSV_FILE_NOT_EXISTING')
# set stop condition
stop_system_importer_file_csv = True
else:
# no read permission for CSV import file - stop immediately
if not os.access(csv_import_file, os.R_OK):
# if function was called from 'system_instant'
if request:
# call messsage
messages.error(
request,
'No read permission for CSV import file. Check config or file system!'
)
# if function was called from 'system_cron'
else:
# call message for all users
error_message_cron(
'No read permission for CSV import file. Check config or file system!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV_FILE_NO_READ_PERMISSION')
# set stop condition
stop_system_importer_file_csv = True
else:
# CSV import file is empty - stop immediately
if os.path.getsize(csv_import_file) == 0:
# if function was called from 'system_instant'
if request:
# call messsage
messages.error(
request,
'CSV import file is empty. Check config or file system!'
)
# if function was called from 'system_cron'
else:
# call message for all users
error_message_cron(
'CSV import file is empty. Check config or file system!'
)
# call logger
error_logger(logger_username,
' SYSTEM_IMPORTER_FILE_CSV_FILE_EMPTY')
# set stop condition
stop_system_importer_file_csv = True
# return stop condition to 'csv.system_create_cron' or 'csv.system_cron' or 'csv.system_instant'
return stop_system_importer_file_csv
def check_config_attributes(model, request=None):
""" check config for logic errors about attributes """
# reset stop condition
stop_system_importer_file_csv = False
""" set username for logger """
# if function was called from 'system_instant' or 'system_upload' or 'system_create_cron'
if request:
logger_username = str(request.user)
# if function was called from 'system_cron'
else:
logger_username = model.csv_import_username.username # check for existence of user in config was done before
""" check numeric values for column fields """
# CSV_COLUMN_SYSTEM
if not 1 <= model.csv_column_system <= 99:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'`CSV_COLUMN_SYSTEM` is outside the allowed range. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV variable CSV_COLUMN_SYSTEM out of range'
)
# set stop condition
stop_system_importer_file_csv = True
# CSV_COLUMN_IP
if model.csv_column_ip:
# check CSV_COLUMN_IP for value
if not 1 <= model.csv_column_ip <= 99:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'`CSV_COLUMN_IP` is outside the allowed range. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV variable CSV_COLUMN_IP out of range'
)
# set stop condition
stop_system_importer_file_csv = True
# CSV_COLUMN_DNSNAME
if model.csv_column_dnsname:
# check CSV_COLUMN_DNSNAME for value
if not 1 <= model.csv_column_dnsname <= 99:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'`CSV_COLUMN_DNSNAME` is outside the allowed range. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV variable CSV_COLUMN_DNSNAME out of range'
)
# set stop condition
stop_system_importer_file_csv = True
# CSV_COLUMN_DOMAIN
if model.csv_column_domain:
# check CSV_COLUMN_DOMAIN for value
if not 1 <= model.csv_column_domain <= 99:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'`CSV_COLUMN_DOMAIN` is outside the allowed range. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV variable CSV_COLUMN_DOMAIN out of range'
)
# set stop condition
stop_system_importer_file_csv = True
# CSV_COLUMN_LOCATION
if model.csv_column_location:
# check CSV_COLUMN_LOCATION for value
if not 1 <= model.csv_column_location <= 99:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'`CSV_COLUMN_LOCATION` is outside the allowed range. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV variable CSV_COLUMN_LOCATION out of range'
)
# set stop condition
stop_system_importer_file_csv = True
# CSV_COLUMN_OS
if model.csv_column_os:
# check CSV_COLUMN_OS for value
if not 1 <= model.csv_column_os <= 99:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'`CSV_COLUMN_OS` is outside the allowed range. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV variable CSV_COLUMN_OS out of range'
)
# set stop condition
stop_system_importer_file_csv = True
# CSV_COLUMN_REASON
if model.csv_column_reason:
# check CSV_COLUMN_REASON for value
if not 1 <= model.csv_column_reason <= 99:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'`CSV_COLUMN_REASON` is outside the allowed range. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV variable CSV_COLUMN_REASON out of range'
)
# set stop condition
stop_system_importer_file_csv = True
# CSV_COLUMN_RECOMMENDATION
if model.csv_column_recommendation:
# check CSV_COLUMN_RECOMMENDATION for value
if not 1 <= model.csv_column_recommendation <= 99:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'`CSV_COLUMN_RECOMMENDATION` is outside the allowed range. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV variable CSV_COLUMN_RECOMMENDATION out of range'
)
# set stop condition
stop_system_importer_file_csv = True
# CSV_COLUMN_SERVICEPROVIDER
if model.csv_column_serviceprovider:
# check CSV_COLUMN_SERVICEPROVIDER for value
if not 1 <= model.csv_column_serviceprovider <= 99:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'`CSV_COLUMN_SERVICEPROVIDER` is outside the allowed range. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV variable CSV_COLUMN_SERVICEPROVIDER out of range'
)
# set stop condition
stop_system_importer_file_csv = True
# CSV_COLUMN_SYSTEMTYPE
if model.csv_column_systemtype:
# check CSV_COLUMN_SYSTEMTYPE for value
if not 1 <= model.csv_column_systemtype <= 99:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'`CSV_COLUMN_SYSTEMTYPE` is outside the allowed range. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV variable CSV_COLUMN_SYSTEMTYPE out of range'
)
# set stop condition
stop_system_importer_file_csv = True
# CSV_COLUMN_CASE
if model.csv_column_case:
# check CSV_COLUMN_CASE for value
if not 1 <= model.csv_column_case <= 99:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'`CSV_COLUMN_CASE` is outside the allowed range. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV variable CSV_COLUMN_CASE out of range'
)
# set stop condition
stop_system_importer_file_csv = True
# CSV_COLUMN_COMPANY
if model.csv_column_company:
# check CSV_COLUMN_COMPANY for value
if not 1 <= model.csv_column_company <= 99:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'`CSV_COLUMN_COMPANY` is outside the allowed range. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV variable CSV_COLUMN_COMPANY out of range'
)
# set stop condition
stop_system_importer_file_csv = True
# CSV_COLUMN_TAG
if model.csv_column_tag:
# check CSV_COLUMN_TAG for value
if not 1 <= model.csv_column_tag <= 99:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'`CSV_COLUMN_TAG` is outside the allowed range. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV variable CSV_COLUMN_TAG out of range'
)
# set stop condition
stop_system_importer_file_csv = True
""" check for EITHER 'choice' and 'column' OR 'default' """
# reset error condition
attribute_error = False
# set error counter
attribute_error_counter = 0
# create empty list for error IDs
attribute_error_id = []
# ip - CSV chosen and no CSV column filled out
if model.csv_choice_ip and not model.csv_column_ip:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('ip_01')
# ip - CSV not chosen and CSV column filled out
if not model.csv_choice_ip and model.csv_column_ip:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('ip_02')
# dnsname - CSV chosen and no CSV column filled out
if model.csv_choice_dnsname and not model.csv_column_dnsname:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('dnsname_01')
# dnsname - CSV not chosen and CSV column filled out
if not model.csv_choice_dnsname and model.csv_column_dnsname:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('dnsname_02')
# dnsname - CSV chosen and DB chosen
if model.csv_choice_dnsname and model.csv_default_dnsname:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('dnsname_03')
# dnsname - CSV column filled out and DB chosen
if model.csv_column_dnsname and model.csv_default_dnsname:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('dnsname_04')
# domain - CSV chosen and no CSV column filled out
if model.csv_choice_domain and not model.csv_column_domain:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('domain_01')
# domain - CSV not chosen and CSV column filled out
if not model.csv_choice_domain and model.csv_column_domain:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('domain_02')
# domain - CSV chosen and DB chosen
if model.csv_choice_domain and model.csv_default_domain:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('domain_03')
# domain - CSV column filled out and DB chosen
if model.csv_column_domain and model.csv_default_domain:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('domain_04')
# location - CSV chosen and no CSV column filled out
if model.csv_choice_location and not model.csv_column_location:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('location_01')
# location - CSV not chosen and CSV column filled out
if not model.csv_choice_location and model.csv_column_location:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('location_02')
# location - CSV chosen and DB chosen
if model.csv_choice_location and model.csv_default_location:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('location_03')
# location - CSV column filled out and DB chosen
if model.csv_column_location and model.csv_default_location:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('location_04')
# os - CSV chosen and no CSV column filled out
if model.csv_choice_os and not model.csv_column_os:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('os_01')
# os - CSV not chosen and CSV column filled out
if not model.csv_choice_os and model.csv_column_os:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('os_02')
# os - CSV chosen and DB chosen
if model.csv_choice_os and model.csv_default_os:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('os_03')
# os - CSV column filled out and DB chosen
if model.csv_column_os and model.csv_default_os:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('os_04')
# reason - CSV chosen and no CSV column filled out
if model.csv_choice_reason and not model.csv_column_reason:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('reason_01')
# reason - CSV not chosen and CSV column filled out
if not model.csv_choice_reason and model.csv_column_reason:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('reason_02')
# reason - CSV chosen and DB chosen
if model.csv_choice_reason and model.csv_default_reason:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('reason_03')
# reason - CSV column filled out and DB chosen
if model.csv_column_reason and model.csv_default_reason:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('reason_04')
# recommendation - CSV chosen and no CSV column filled out
if model.csv_choice_recommendation and not model.csv_column_recommendation:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('recommendation_01')
# recommendation - CSV not chosen and CSV column filled out
if not model.csv_choice_recommendation and model.csv_column_recommendation:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('recommendation_02')
# recommendation - CSV chosen and DB chosen
if model.csv_choice_recommendation and model.csv_default_recommendation:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('recommendation_03')
# recommendation - CSV column filled out and DB chosen
if model.csv_column_recommendation and model.csv_default_recommendation:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('recommendation_04')
# serviceprovider - CSV chosen and no CSV column filled out
if model.csv_choice_serviceprovider and not model.csv_column_serviceprovider:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('serviceprovider_01')
# serviceprovider - CSV not chosen and CSV column filled out
if not model.csv_choice_serviceprovider and model.csv_column_serviceprovider:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('serviceprovider_02')
# serviceprovider - CSV chosen and DB chosen
if model.csv_choice_serviceprovider and model.csv_default_serviceprovider:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('serviceprovider_03')
# serviceprovider - CSV column filled out and DB chosen
if model.csv_column_serviceprovider and model.csv_default_serviceprovider:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('serviceprovider_04')
# systemtype - CSV chosen and no CSV column filled out
if model.csv_choice_systemtype and not model.csv_column_systemtype:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('systemtype_01')
# systemtype - CSV not chosen and CSV column filled out
if not model.csv_choice_systemtype and model.csv_column_systemtype:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('systemtype_02')
# systemtype - CSV chosen and DB chosen
if model.csv_choice_systemtype and model.csv_default_systemtype:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('systemtype_03')
# systemtype - CSV column filled out and DB chosen
if model.csv_column_systemtype and model.csv_default_systemtype:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('systemtype_04')
# case - CSV chosen and no CSV column filled out
if model.csv_choice_case and not model.csv_column_case:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('case_01')
# case - CSV not chosen and CSV column filled out
if not model.csv_choice_case and model.csv_column_case:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('case_02')
# case - CSV chosen and DB chosen
if model.csv_choice_case and model.csv_default_case.all():
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('case_03')
# case - CSV column filled out and DB chosen
if model.csv_column_case and model.csv_default_case.all():
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('case_04')
# company - CSV chosen and no CSV column filled out
if model.csv_choice_company and not model.csv_column_company:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('company_01')
# company - CSV not chosen and CSV column filled out
if not model.csv_choice_company and model.csv_column_company:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('company_02')
# company - CSV chosen and DB chosen
if model.csv_choice_company and model.csv_default_company.all():
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('company_03')
# company - CSV column filled out and DB chosen
if model.csv_column_company and model.csv_default_company.all():
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('company_04')
# tag - CSV chosen and no CSV column filled out
if model.csv_choice_tag and not model.csv_column_tag:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('tag_01')
# tag - CSV not chosen and CSV column filled out
if not model.csv_choice_tag and model.csv_column_tag:
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('tag_02')
# tag - CSV chosen and DB chosen
if model.csv_choice_tag and model.csv_default_tag.all():
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('tag_03')
# tag - CSV column filled out and DB chosen
if model.csv_column_tag and model.csv_default_tag.all():
# set attribute error
attribute_error = True
# autoincrement counter
attribute_error_counter += 1
# add error code
attribute_error_id.append('tag_04')
# check previous checks for error - one message / log for all
if attribute_error:
# if function was called from 'system_instant' or 'system_upload'
if request:
if attribute_error_counter == 1:
# call message
messages.error(
request,
f'There was {attribute_error_counter} error regarding attributes. Check config!'
)
elif attribute_error_counter > 1:
# call message
messages.error(
request,
f'There were {attribute_error_counter} errors regarding attributes. Check config!'
)
# call logger
error_logger(
logger_username,
f' SYSTEM_IMPORTER_FILE_CSV attributes misconfigured {attribute_error_id}'
)
# set stop condition
stop_system_importer_file_csv = True
""" check tag pefix and delimiter in combination with CSV and DB """
# tag - CSV chosen and prefix and / or prefix delimiter not set
if model.csv_choice_tag and (not model.csv_tag_prefix
or not model.csv_tag_prefix_delimiter):
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'Choose prefix and delimiter for tag import from CSV to distinguish between manual set tags.'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV tag prefix and / or tag delimiter not set'
)
# set stop condition
stop_system_importer_file_csv = True
# tag - DB chosen and prefix and / or prefix delimiter chosen
if model.csv_default_tag.all() and (model.csv_tag_prefix
or model.csv_tag_prefix_delimiter):
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'Prefix and delimiter are not available when setting tags from database.'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV tag prefix and / or tag delimiter not compatible with csv_default_tag'
)
# set stop condition
stop_system_importer_file_csv = True
# tag - DB chosen but special option 'tag_remove_prefix' set
if model.csv_remove_tag == 'tag_remove_prefix' and model.csv_default_tag.all(
):
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'Removing tags with prefix is only available when setting tags from CSV.'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV remove tags with prefix not compatible with csv_default_tag'
)
# set stop condition
stop_system_importer_file_csv = True
""" check tagfree choices (systemstatus / analysisstatus) in combination with tag from CSV """
# tag - alternative choice systemstatus (tagfree) chosen without tag choice from CSV
if model.csv_choice_tagfree_systemstatus and not model.csv_choice_tag:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'Alternative systemstatus only available with tags from CSV.')
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV tagfree systemstatus only compatible with csv_choice_tag'
)
# set stop condition
stop_system_importer_file_csv = True
# tag - alternative choice analysisstatus (tagfree) chosen without tag choice from CSV
if model.csv_choice_tagfree_analysisstatus and not model.csv_choice_tag:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'Alternative analysisstatus only available with tags from CSV.'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV tagfree analysisstatus only compatible with csv_choice_tag'
)
# set stop condition
stop_system_importer_file_csv = True
""" check if the column fields are different """
# reset error condition
column_error = False
# create empty dict for column values
all_columns_dict = {}
# add column values to dict
all_columns_dict['csv_column_system'] = model.csv_column_system
if model.csv_column_ip:
all_columns_dict['csv_column_ip'] = model.csv_column_ip
if model.csv_column_dnsname:
all_columns_dict['csv_column_dnsname'] = model.csv_column_dnsname
if model.csv_column_domain:
all_columns_dict['csv_column_domain'] = model.csv_column_domain
if model.csv_column_location:
all_columns_dict['csv_column_location'] = model.csv_column_location
if model.csv_column_os:
all_columns_dict['csv_column_os'] = model.csv_column_os
if model.csv_column_reason:
all_columns_dict['csv_column_reason'] = model.csv_column_reason
if model.csv_column_recommendation:
all_columns_dict[
'csv_column_recommendation'] = model.csv_column_recommendation
if model.csv_column_serviceprovider:
all_columns_dict[
'csv_column_serviceprovider'] = model.csv_column_serviceprovider
if model.csv_column_systemtype:
all_columns_dict['csv_column_systemtype'] = model.csv_column_systemtype
if model.csv_column_case:
all_columns_dict['csv_column_case'] = model.csv_column_case
if model.csv_column_company:
all_columns_dict['csv_column_company'] = model.csv_column_company
if model.csv_column_tag:
all_columns_dict['csv_column_tag'] = model.csv_column_tag
# check all column values against each other
for column in all_columns_dict:
# explicitly copy dict
pruned_columns_dict = dict(all_columns_dict)
# remove column from copied dict
del pruned_columns_dict[column]
# check for the same value in pruned dict
if all_columns_dict[column] in pruned_columns_dict.values():
# set error condition
column_error = True
# check previous checks for error - one message / log for all
if column_error:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(request,
'The columns have to be unique. Check config!')
# call logger
error_logger(logger_username,
' SYSTEM_IMPORTER_FILE_CSV columns not unique')
# set stop condition
stop_system_importer_file_csv = True
""" check remove conditions in combination with skip condition """
# reset error condition
remove_error = False
# remove systemstatus
if model.csv_skip_existing_system and model.csv_remove_systemstatus:
# set remove error
remove_error = True
# remove analysisstatus
if model.csv_skip_existing_system and model.csv_remove_analysisstatus:
# set remove error
remove_error = True
# remove ip
if model.csv_skip_existing_system and model.csv_remove_ip:
# set remove error
remove_error = True
# remove dnsname
if model.csv_skip_existing_system and model.csv_remove_dnsname:
# set remove error
remove_error = True
# remove domain
if model.csv_skip_existing_system and model.csv_remove_domain:
# set remove error
remove_error = True
# remove location
if model.csv_skip_existing_system and model.csv_remove_location:
# set remove error
remove_error = True
# remove os
if model.csv_skip_existing_system and model.csv_remove_os:
# set remove error
remove_error = True
# remove reason
if model.csv_skip_existing_system and model.csv_remove_reason:
# set remove error
remove_error = True
# remove recommendation
if model.csv_skip_existing_system and model.csv_remove_recommendation:
# set remove error
remove_error = True
# remove serviceprovider
if model.csv_skip_existing_system and model.csv_remove_serviceprovider:
# set remove error
remove_error = True
# remove systemtype
if model.csv_skip_existing_system and model.csv_remove_systemtype:
# set remove error
remove_error = True
# remove case
if model.csv_skip_existing_system and model.csv_remove_case:
# set remove error
remove_error = True
# remove company
if model.csv_skip_existing_system and model.csv_remove_company:
# set remove error
remove_error = True
# check previous checks for error - one message / log for all
if remove_error:
# if function was called from 'system_instant' or 'system_upload'
if request:
# call message
messages.error(
request,
'There is an error regarding removing existing attributes. Check config!'
)
# call logger
error_logger(
logger_username,
' SYSTEM_IMPORTER_FILE_CSV remove attributes misconfigured ')
# set stop condition
stop_system_importer_file_csv = True
""" check remove conditions without CSV or DB """
# TODO: [code] add checks like in 'dfirtrack_config.forms'
""" call single message (to avoid noise) for all users and return """
# error occurred and function was called from 'system_cron'
if stop_system_importer_file_csv and not request:
# call message for all users
error_message_cron(
'There was an error within the configuration. Check config!')
# return stop condition to 'csv.system_create_cron' or 'csv.system_cron' or 'csv.system_instant' or 'csv.system_upload'
return stop_system_importer_file_csv
def reportitems(request):
""" this function checks for every system the existence of a markdown file with information about the and imports the content of this file as reportitem for the corresponding system """
# call logger
debug_logger(str(request.user), " REPORTITEM_FILESYSTEM_IMPORTER_BEGIN")
# check whether REPORTITEMS_FILESYSTEMPATH is defined in `dfirtrack.config`
if reportitems_filesystempath == '':
# call logger
error_logger(str(request.user),
" REPORTITEMS_FILESYSTEMPATH_VARIABLE_UNDEFINED")
messages.error(
request,
"The variable REPORTITEMS_FILESYSTEMPATH seems to be undefined. Check `dfirtrack.config`!"
)
# leave importer
return redirect('/systems/')
# check whether REPORTITEMS_FILESYSTEMPATH points to non-existing directory
if not os.path.isdir(reportitems_filesystempath):
# call logger
error_logger(str(request.user),
" REPORTITEMS_FILESYSTEM_IMPORTER_WRONG_PATH")
messages.error(
request,
"The variable REPORTITEMS_FILESYSTEMPATH points to a non-existing directory. Check `dfirtrack.config`!"
)
# leave importer
return redirect('/systems/')
# check whether REPORTITEMS_HEADLINE is defined in `dfirtrack.config`
if reportitems_headline == '':
# call logger
error_logger(str(request.user),
" REPORTITEMS_HEADLINE_VARIABLE_UNDEFINED")
messages.error(
request,
"The variable REPORTITEMS_HEADLINE seems to be undefined. Check `dfirtrack.config`!"
)
# leave importer
return redirect('/systems/')
# check whether REPORTITEMS_SUBHEADLINE is defined in `dfirtrack.config`
if reportitems_subheadline == '':
# call logger
error_logger(str(request.user),
" REPORTITEMS_SUBHEADLINE_VARIABLE_UNDEFINED")
messages.error(
request,
"The variable REPORTITEMS_SUBHEADLINE seems to be undefined. Check `dfirtrack.config`!"
)
# leave importer
return redirect('/systems/')
# check whether REPORTITEMS_DELETE is defined in `dfirtrack.config`
if not isinstance(reportitems_delete, bool):
# call logger
error_logger(str(request.user),
" REPORTITEMS_DELETE_VARIABLE_UNDEFINED")
messages.error(
request,
"The variable REPORTITEMS_DELETE seems to be undefined or not a boolean. Check `dfirtrack.config`!"
)
# leave importer
return redirect('/systems/')
# get all system objects
systems = System.objects.all()
# create headline if it does not exist
headline, created = Headline.objects.get_or_create(
headline_name=reportitems_headline)
if created == True:
# call logger
headline.logger(str(request.user),
" REPORTITEMS_FILESYSTEM_IMPORTER_HEADLINE_CREATED")
# set counter for non-existing files (needed for messages)
nofile_found_counter = 0
# set counter for created reportitems (needed for messages)
reportitems_created_counter = 0
# set counter for modified reportitems (needed for messages)
reportitems_modified_counter = 0
# set counter for deleted reportitems (needed for messages)
reportitems_deleted_counter = 0
# iterate over systems
for system in systems:
# create path for reportfile
reportpath = reportitems_filesystempath + "/" + system.system_name + ".md"
# check whether a file is existing for this system
if not os.path.isfile(reportpath):
# call logger
warning_logger(
str(request.user),
" REPORTITEMS_FILESYSTEM_IMPORTER_NO_FILE system_name:" +
system.system_name)
# autoincrement counter
nofile_found_counter += 1
# check whether already existing reportitem for this system should be deleted if no file was provided
if reportitems_delete:
# delete already existing reportitem for this system if no file was provided
try:
reportitem = Reportitem.objects.get(
system=system,
headline=headline,
reportitem_subheadline=reportitems_subheadline)
# call logger (before deleting instance)
reportitem.logger(
str(request.user),
" REPORTITEMS_FILESYSTEM_IMPORTER_REPORTITEM_DELETED")
reportitem.delete()
# autoincrement counter
reportitems_deleted_counter += 1
except Reportitem.DoesNotExist:
pass
# continue with next system
continue
# create reportitem if it does not exist (get_or_create won't work in this context because of needed user objects for saving)
try:
reportitem = Reportitem.objects.get(
system=system,
headline=headline,
reportitem_subheadline=reportitems_subheadline)
reportitems_modified_counter += 1
except Reportitem.DoesNotExist:
reportitem = Reportitem()
reportitems_created_counter += 1
reportitem.system = system
reportitem.headline = headline
reportitem.reportitem_subheadline = reportitems_subheadline
reportitem.reportitem_created_by_user_id = request.user
# open file
reportfile = open(reportpath, "r")
# add changing values (existing reportitem_note will be overwritten)
reportitem.reportitem_note = reportfile.read()
# close file
reportfile.close()
reportitem.reportitem_modified_by_user_id = request.user
reportitem.save()
# call logger
reportitem.logger(
str(request.user),
" REPORTITEMS_FILESYSTEM_IMPORTER_REPORTITEM_CREATED_OR_MODIFIED")
# call final messages
if nofile_found_counter > 0:
if nofile_found_counter == 1:
messages.warning(
request, "No file was found for " + str(nofile_found_counter) +
" system.")
else:
messages.warning(
request, "No files were found for " +
str(nofile_found_counter) + " systems.")
if reportitems_created_counter > 0:
if reportitems_created_counter == 1:
messages.success(
request,
str(reportitems_created_counter) + ' reportitem was created.')
else:
messages.success(
request,
str(reportitems_created_counter) +
' reportitems were created.')
if reportitems_modified_counter > 0:
if reportitems_modified_counter == 1:
messages.success(
request,
str(reportitems_modified_counter) +
' reportitem was modified.')
else:
messages.success(
request,
str(reportitems_modified_counter) +
' reportitems were modified.')
if reportitems_deleted_counter > 0:
if reportitems_deleted_counter == 1:
messages.success(
request,
str(reportitems_deleted_counter) + ' reportitem was deleted.')
else:
messages.success(
request,
str(reportitems_deleted_counter) +
' reportitems were deleted.')
return redirect('/systems/')
def system_creator_async(request_post, request_user):
""" function to create many systems at once """
# call logger
debug_logger(str(request_user), ' SYSTEM_CREATOR_BEGIN')
# exctract lines from systemlist (list results from request object via large text area)
lines = request_post.get('systemlist').splitlines()
# count lines (needed for messages)
number_of_lines = len(lines)
# set systems_created_counter (needed for messages)
systems_created_counter = 0
# set systems_skipped_counter (needed for messages)
systems_skipped_counter = 0
# set lines_faulty_counter (needed for messages)
lines_faulty_counter = 0
# create empty list (needed for messages)
skipped_systems = []
# iterate over lines
for line in lines:
# skip emtpy lines
if line == '':
# autoincrement counter
lines_faulty_counter += 1
# call logger
warning_logger(str(request_user), ' SYSTEM_CREATOR_ROW_EMPTY')
continue
# check line for length of string
if len(line) > 50:
# autoincrement counter
lines_faulty_counter += 1
# call logger
warning_logger(str(request_user), ' SYSTEM_CREATOR_LONG_STRING')
continue
# check for existence of system
system = System.objects.filter(system_name=line)
""" already existing system """
# in case of existing system
if system.count() > 0:
# autoincrement counter
systems_skipped_counter += 1
# add system name to list of skipped systems
skipped_systems.append(line)
# call logger
error_logger(
str(request_user),
' SYSTEM_CREATOR_SYSTEM_EXISTS ' + 'system_name:' + line)
# leave this loop because system with this systemname already exists
continue
""" new system """
# create form with request data
form = SystemCreatorForm(request_post)
# create system
if form.is_valid():
""" object creation """
# don't save form yet
system = form.save(commit=False)
# set system_name
system.system_name = line
# set auto values
system.system_created_by_user_id = request_user
system.system_modified_by_user_id = request_user
system.system_modify_time = timezone.now()
# save object
system.save()
# save manytomany
form.save_m2m()
""" object counter / log """
# autoincrement counter
systems_created_counter += 1
# call logger
system.logger(str(request_user), ' SYSTEM_CREATOR_EXECUTED')
""" call final messages """
# finish message
message_user(request_user, 'System creator finished', constants.SUCCESS)
# number messages
if systems_created_counter > 0:
if systems_created_counter == 1:
message_user(request_user,
str(systems_created_counter) + ' system was created.',
constants.SUCCESS)
else:
message_user(
request_user,
str(systems_created_counter) + ' systems were created.',
constants.SUCCESS)
if systems_skipped_counter > 0:
if systems_skipped_counter == 1:
message_user(
request_user,
str(systems_skipped_counter) + ' system was skipped. ' +
str(skipped_systems), constants.ERROR)
else:
message_user(
request_user,
str(systems_skipped_counter) + ' systems were skipped. ' +
str(skipped_systems), constants.ERROR)
if lines_faulty_counter > 0:
if lines_faulty_counter == 1:
message_user(
request_user,
str(lines_faulty_counter) + ' line out of ' +
str(number_of_lines) +
' lines was faulty (see log file for details).',
constants.WARNING)
else:
message_user(
request_user,
str(lines_faulty_counter) + ' lines out of ' +
str(number_of_lines) +
' lines were faulty (see log file for details).',
constants.WARNING)
# call logger
info_logger(
str(request_user),
' SYSTEM_CREATOR_STATUS ' + 'created:' + str(systems_created_counter) +
'|' + 'skipped:' + str(systems_skipped_counter) + '|' +
'faulty_lines:' + str(lines_faulty_counter))
# call logger
debug_logger(str(request_user), ' SYSTEM_CREATOR_END')
def system(request):
# get user string
request_user = str(request.user)
# call logger
debug_logger(request_user, " API_GIRAF_SYSTEMS_BEGIN")
# check variables in `dfirtrack.config`
stop_importer_api_giraf = check_config(request)
# leave importer_api_giraf if variables caused errors
if stop_importer_api_giraf:
return redirect(reverse('system_list'))
# check connection
try:
urllib.request.urlopen(dfirtrack_config.GIRAF_URL, timeout=2)
except:
# call logger
error_logger(request_user, " API_GIRAF_SYSTEMS_URL_NOT_AVAILABLE")
messages.error(request, "GIRAF API URL not available.")
# call logger (for consistency purposes to show end of api call)
debug_logger(request_user, " API_GIRAF_SYSTEMS_END")
return redirect(reverse('system_list'))
# get JSON from GIRAF API (returns <class 'requests.models.Response'>)
system_json = requests.get(
dfirtrack_config.GIRAF_URL + '/api/systems/systems/',
auth=(dfirtrack_config.GIRAF_USER, dfirtrack_config.GIRAF_PASS))
# load JSON to list (returns list if authenticated, returns dict else)
system_list = system_json.json()
# check for list type (in case of auth error it returns dict)
if type(system_list) != list:
""" stop api call because of missing list """
# call logger
error_logger(request_user, " API_GIRAF_POSSIBLE_AUTH_ERROR")
messages.error(request, "GIRAF API possible authentication error.")
# call logger (for consistency purposes to show end of api call)
debug_logger(request_user, " API_GIRAF_SYSTEMS_END")
return redirect(reverse('system_list'))
# iterate over systems
for system_dict in system_list:
# get hostname and uuid
try:
hostname = system_dict['hostname']
except:
# leave this loop if there is something wrong with the data
error_logger(request_user, " API_GIRAF_WRONG_DATA")
continue
# get uuid
uuid = system_dict['uuid']
# get list of ips
ip_list = system_dict['ip_address']
# get list of systemusers
systemuser_list = system_dict['systemuser']
# get domain
domain = system_dict['domain']
domain, created = Domain.objects.get_or_create(domain_name=domain)
if created == True:
# call logger
domain.logger(request_user, " API_GIRAF_SYSTEMS_DOMAIN_CREATED")
# get Os
osimportname = str(system_dict['os']) + " " + str(
system_dict['release']) + " " + str(system_dict['version'])
osimportname, created = Osimportname.objects.get_or_create(
osimportname_name=osimportname,
osimportname_importer='GIRAF',
defaults={
'os': Os.objects.get(os_name='tbd')
}, # set 'tbd' if no mapping exists, real os will be updated after next api call after mapping
)
# get architecture
osarch = system_dict['machine_type']
osarch, created = Osarch.objects.get_or_create(osarch_name=osarch)
if created == True:
# call logger
osarch.logger(request_user, " API_GIRAF_SYSTEMS_OSARCH_CREATED")
# get installation date
install_date = system_dict['install_date']
if install_date is not None:
install_date = dateutil.parser.parse(install_date)
# get boot time
last_booted_at = system_dict['last_booted_at']
if last_booted_at is not None:
last_booted_at = dateutil.parser.parse(last_booted_at)
# check for uuid
system = System.objects.filter(system_uuid=uuid)
if not system: # uuid:no
# check for hostname
system = System.objects.filter(system_name=hostname)
if not system: # hostname:no
system = System() # create new system object
system.system_name = hostname
system.systemstatus = Systemstatus.objects.get(
systemstatus_name='Unknown')
system.system_created_by_user_id = request.user
system.system_modified_by_user_id = request.user
system.system_modify_time = timezone.now()
system.save() # hostname:yes
#system = System.objects.filter(system_name=hostname, domain.domain_name=domain)
#if not system: # if system with this hostname and domain doesn't exit
# pass
#else:
# system = System.objects.filter(system_name=hostname, domain.domain_name=domain, system_install_time=FOO)
system = System.objects.get(
system_name=hostname
) # Get system for the case uuid:no hostname:yes
system.system_uuid = uuid # uuid:yes
# iterate over ips
for ip_dict in ip_list:
ip = ip_dict['ip_address']
# get or create ip object
ip, created = Ip.objects.get_or_create(ip_ip=ip)
if created == True:
ip.logger(request_user, " API_GIRAF_SYSTEMS_IP_CREATED")
# check whether ip already exists for this system otherwise add fk-relationship
if system.ip.filter(ip_ip=ip.ip_ip).exists() is False:
system.ip.add(ip)
# iterate over systemusers
for systemuser_dict in systemuser_list:
systemuser_name = systemuser_dict['username']
systemuser_lastlogon_time = systemuser_dict['last_logon']
if systemuser_lastlogon_time is not None:
systemuser_lastlogon_time = dateutil.parser.parse(
systemuser_lastlogon_time)
# get or create systemuser object (check isn't required because system is already bind by this)
systemuser, created = Systemuser.objects.get_or_create(
systemuser_name=systemuser_name, system=system)
# update logon time (not suitable for searching above)
systemuser.systemuser_lastlogon_time = systemuser_lastlogon_time
systemuser.save()
if created == True:
systemuser.logger(request_user,
" API_GIRAF_SYSTEMS_SYSTEMUSER_CREATED")
system.domain = domain
system.os = osimportname.os # set OS to existing mapping or 'tbd'
system.osarch = osarch
system.system_install_time = install_date
system.system_lastbooted_time = last_booted_at
# set auto values
system.system_api_time = timezone.now()
# save object
system.save()
# call logger
system.logger(request_user, ' API_GIRAF_SYSTEMS_EXECUTED')
else: # uuid:yes
system = System.objects.get(system_uuid=uuid)
# iterate over ips
for ip_dict in ip_list:
ip = ip_dict['ip_address']
# get or create ip object
ip, created = Ip.objects.get_or_create(ip_ip=ip)
if created == True:
ip.logger(request_user, " API_GIRAF_SYSTEMS_IP_CREATED")
# check whether ip already exists for this system otherwise add fk-relationship
if system.ip.filter(ip_ip=ip.ip_ip).exists() is False:
system.ip.add(ip)
# iterate over systemusers
for systemuser_dict in systemuser_list:
systemuser_name = systemuser_dict['username']
systemuser_lastlogon_time = systemuser_dict['last_logon']
if systemuser_lastlogon_time is not None:
systemuser_lastlogon_time = dateutil.parser.parse(
systemuser_lastlogon_time)
# get or create systemuser object (check isn't required because system is already bind by this)
systemuser, created = Systemuser.objects.get_or_create(
systemuser_name=systemuser_name, system=system)
# update logon time (not suitable for searching above)
systemuser.systemuser_lastlogon_time = systemuser_lastlogon_time
systemuser.save()
if created == True:
# call logger
systemuser.logger(request_user,
" API_GIRAF_SYSTEMS_SYSTEMUSER_CREATED")
system.domain = domain
system.os = osimportname.os # set OS to existing mapping or 'tbd'
system.osarch = osarch
system.system_install_time = install_date
system.system_lastbooted_time = last_booted_at
# set auto values
system.system_api_time = timezone.now()
# save object
system.save()
# call logger
system.logger(request_user, ' API_GIRAF_SYSTEMS_EXECUTED')
# call logger
debug_logger(request_user, " API_GIRAF_SYSTEMS_END")
return redirect(reverse('system_list'))
def check_content_file_system(request=None):
"""check file system"""
# get config model
model = SystemExporterMarkdownConfigModel.objects.get(
system_exporter_markdown_config_name='SystemExporterMarkdownConfig')
# reset stop condition
stop_exporter_markdown = False
""" set username for logger """
# get config
main_config_model = MainConfigModel.objects.get(
main_config_name='MainConfig')
# if function was called from 'system' / 'system_create_cron'
if request:
logger_username = str(request.user)
# if function was called from 'system_cron'
else:
logger_username = main_config_model.cron_username
# check MARKDOWN_PATH for empty string - stop immediately
if not model.markdown_path:
# if function was called from 'system'
if request:
messages.error(
request,
'Markdown path contains an empty string. Check config!')
# if function was called from 'system_cron'
else:
error_message_cron(
'Markdown path contains an empty string. Check config!')
# call logger
error_logger(logger_username,
' MARKDOWN_EXPORTER_MARKDOWN_PATH_EMPTY_STRING')
# set stop condition
stop_exporter_markdown = True
else:
# check MARKDOWN_PATH for existence in file system - stop immediately
if not os.path.isdir(model.markdown_path):
# if function was called from 'system'
if request:
messages.error(
request,
'Markdown path does not exist. Check config or file system!',
)
# if function was called from 'system_cron'
else:
error_message_cron(
'Markdown path does not exist. Check config or file system!'
)
# call logger
error_logger(logger_username,
' MARKDOWN_EXPORTER_MARKDOWN_PATH_NOT_EXISTING')
# set stop condition
stop_exporter_markdown = True
else:
# check MARKDOWN_PATH for write permission - stop immediately
if not os.access(model.markdown_path, os.W_OK):
# if function was called from 'system'
if request:
messages.error(
request,
'No write permission for markdown path. Check config or file system!',
)
# if function was called from 'system_cron'
else:
error_message_cron(
'No write permission for markdown path. Check config or file system!'
)
# call logger
error_logger(
logger_username,
' MARKDOWN_EXPORTER_MARKDOWN_PATH_NO_WRITE_PERMISSION',
)
# set stop condition
stop_exporter_markdown = True
# return stop condition
return stop_exporter_markdown
def system_modificator_async(request_post, request_user):
""" function to modify many systems at once """
# call logger
debug_logger(str(request_user), " SYSTEM_MODIFICATOR_BEGIN")
# exctract lines from systemlist (list results from request object via large text area)
lines = request_post.get('systemlist').splitlines()
# iterate over lines
for line in lines:
# skip emtpy lines
if line == '':
warning_logger(str(request_user), " SYSTEM_MODIFICATOR_ROW_EMPTY")
continue
# check line for string
if not isinstance(line, str):
warning_logger(str(request_user), " SYSTEM_MODIFICATOR_NO_STRING")
continue
# check line for length of string
if len(line) > 50:
warning_logger(str(request_user), " SYSTEM_MODIFICATOR_LONG_STRING")
continue
# check for existence of system
system = System.objects.filter(system_name = line)
if system.count() == 0:
# call logger
error_logger(str(request_user), " SYSTEM_MODIFICATOR_SYSTEM_DOES_NOT_EXISTS " + "system_name:" + line)
# leave this loop because system with this systemname does not exist
continue
elif system.count() > 1:
# call logger
error_logger(str(request_user), " SYSTEM_MODIFICATOR_SYSTEM_NOT_DISTINCT " + "system_name:" + line)
# leave this loop because system with this systemname is not distinct
continue
# get existing system
system = System.objects.get(system_name = line)
# create form with request data
form = SystemModificatorForm(request_post, instance = system)
# extract tags (list results from request object via multiple choice field)
tags = request_post.getlist('tag')
# modify system
if form.is_valid():
# don't save form yet
system = form.save(commit=False)
# set system_name
system.system_name = line
# set auto values
system.system_modified_by_user_id = request_user
system.system_modify_time = timezone.now()
# save object
system.save()
# call logger
system.logger(str(request_user), ' SYSTEM_MODIFICATOR_EXECUTED')
# TODO: add check for empty list
# add tags (using save_m2m would replace existing tags)
for tag_id in tags:
# get object
tag = Tag.objects.get(tag_id=tag_id)
# add tag to system
system.tag.add(tag)
# call logger
debug_logger(str(request_user), " SYSTEM_MODIFICATOR_END")
def system_modificator_async(request_post, request_user):
""" function to modify many systems at once """
# call logger
debug_logger(str(request_user), ' SYSTEM_MODIFICATOR_BEGIN')
# exctract lines from systemlist (list results either from request object via multiline selector or via large text area)
lines = request_post.getlist('systemlist')
system_char_field_used = False
# if large text area was used, the list contains only one entry with (one or more) line breaks
if len(lines) == 1 and ("\r\n" in lines[0] or not lines[0].isdigit()):
system_char_field_used = True
lines = lines[0].splitlines()
# count lines (needed for messages)
number_of_lines = len(lines)
# set systems_modified_counter (needed for messages)
systems_modified_counter = 0
# set systems_skipped_counter (needed for messages)
systems_skipped_counter = 0
# set lines_faulty_counter (needed for messages)
lines_faulty_counter = 0
# create empty list (needed for messages)
skipped_systems = []
# iterate over lines
for line in lines:
# skip emtpy lines
if line == '':
# autoincrement counter
lines_faulty_counter += 1
# call logger
warning_logger(str(request_user), ' SYSTEM_MODIFICATOR_ROW_EMPTY')
continue
# check line for string
if not isinstance(line, str): # coverage: ignore branch
# autoincrement counter
lines_faulty_counter += 1
# call logger
warning_logger(str(request_user), ' SYSTEM_MODIFICATOR_NO_STRING')
continue
# check line for length of string
if len(line) > 50:
# autoincrement counter
lines_faulty_counter += 1
# call logger
warning_logger(str(request_user),
' SYSTEM_MODIFICATOR_LONG_STRING')
continue
# check for existence of system
if system_char_field_used:
system = System.objects.filter(system_name=line)
else:
system = System.objects.filter(system_id=line)
""" handling non-existing or non-unique systems 2 """
# system does not exist
if system.count() == 0:
# autoincrement counter
systems_skipped_counter += 1
# add system name to list of skipped systems
skipped_systems.append(line)
# call logger
error_logger(
str(request_user),
' SYSTEM_MODIFICATOR_SYSTEM_DOES_NOT_EXISTS ' +
'system_id/system_name:' + line)
# leave this loop because system with this systemname does not exist
continue
# more than one system exists
elif system.count() > 1:
# autoincrement counter
systems_skipped_counter += 1
# add system name to list of skipped systems
skipped_systems.append(line)
# call logger
error_logger(
str(request_user), ' SYSTEM_MODIFICATOR_SYSTEM_NOT_DISTINCT ' +
'system_id/system_name:' + line)
# leave this loop because system with this systemname is not distinct
continue
# get existing system
if system_char_field_used:
system = System.objects.get(system_name=line)
else:
system = System.objects.get(system_id=line)
""" new system """
# create form with request data
form = SystemModificatorForm(
request_post,
instance=system,
use_system_charfield=system_char_field_used)
# extract tags (list results from request object via multiple choice field)
tags = request_post.getlist('tag')
# extract companies (list results from request object via multiple choice field)
companies = request_post.getlist('company')
# modify system
if form.is_valid():
""" object modification """
# don't save form yet
system = form.save(commit=False)
# set auto values
system.system_modified_by_user_id = request_user
system.system_modify_time = timezone.now()
# save object
system.save()
""" object counter / log """
# autoincrement counter
systems_modified_counter += 1
# call logger
system.logger(str(request_user), ' SYSTEM_MODIFICATOR_EXECUTED')
""" many 2 many """
# TODO: add check for empty list
# add tags (using save_m2m would replace existing tags)
for tag_id in tags:
# get object
tag = Tag.objects.get(tag_id=tag_id)
# add tag to system
system.tag.add(tag)
for company_id in companies:
# get object
company = Company.objects.get(company_id=company_id)
# add company to system
system.company.add(company)
""" call final messages """
# finish message
message_user(request_user, 'System modificator finished',
constants.SUCCESS)
# number messages
if systems_modified_counter > 0:
if systems_modified_counter == 1:
message_user(
request_user,
str(systems_modified_counter) + ' system was modified.',
constants.SUCCESS)
else:
message_user(
request_user,
str(systems_modified_counter) + ' systems were modified.',
constants.SUCCESS)
if systems_skipped_counter > 0:
if systems_skipped_counter == 1:
message_user(
request_user,
str(systems_skipped_counter) + ' system was skipped. ' +
str(skipped_systems), constants.ERROR)
else:
message_user(
request_user,
str(systems_skipped_counter) + ' systems were skipped. ' +
str(skipped_systems), constants.ERROR)
if lines_faulty_counter > 0:
if lines_faulty_counter == 1:
message_user(
request_user,
str(lines_faulty_counter) + ' line out of ' +
str(number_of_lines) +
' lines was faulty (see log file for details).',
constants.WARNING)
else:
message_user(
request_user,
str(lines_faulty_counter) + ' lines out of ' +
str(number_of_lines) +
' lines were faulty (see log file for details).',
constants.WARNING)
# call logger
info_logger(
str(request_user), ' SYSTEM_MODIFICATOR_STATUS ' + 'modified:' +
str(systems_modified_counter) + '|' + 'skipped:' +
str(systems_skipped_counter) + '|' + 'faulty_lines:' +
str(lines_faulty_counter))
# call logger
debug_logger(str(request_user), " SYSTEM_MODIFICATOR_END")
def systems_ips(request):
""" this function parses a csv file and tries to import systems and corresponding ips """
# form was valid to post
if request.method == "POST":
# call logger
debug_logger(str(request.user), " SYSTEM_IP_IMPORTER_BEGIN")
# get text out of file (variable results from request object via file upload field)
systemipcsv = TextIOWrapper(request.FILES['systemipcsv'].file, encoding=request.encoding)
# read rows out of csv
rows = csv.reader(systemipcsv, quotechar="'")
# set row counter (needed for logger)
i = 0
# check for wrong file type
try:
# iterate over rows
for row in rows:
# autoincrement row counter
i += 1
# check for empty rows
try:
# check system column for empty value
if row[0] == '':
warning_logger(str(request.user), " SYSTEM_IP_IMPORTER_SYSTEM_COLUMN " + "row_" + str(i) + ":empty_column")
continue
except IndexError:
warning_logger(str(request.user), " SYSTEM_IP_IMPORTER_ROW row_" + str(i) + ":empty_row")
continue
# check system column for string
if not isinstance(row[0], str):
warning_logger(str(request.user), " SYSTEM_IP_IMPORTER_SYSTEM_COLUMN " + "row_" + str(i) + ":no_string")
continue
# check system column for length of string
if len(row[0]) > 50:
warning_logger(str(request.user), " SYSTEM_IP_IMPORTER_SYSTEM_COLUMN " + "row_" + str(i) + ":long_string")
continue
# check ip column for ip
try:
ipaddress.ip_address(row[1])
except ValueError:
warning_logger(str(request.user), " SYSTEM_IP_IMPORTER_IP_COLUMN " + "row_" + str(i) + ":invalid_ip")
continue
# create ip
ip, created = Ip.objects.get_or_create(ip_ip=row[1])
if created == True:
ip.logger(str(request.user), " SYSTEMS_IP_IMPORTER_IP_CREATED")
# check for existence of system
system = System.objects.filter(system_name = row[0], ip = ip)
if system.count() > 0:
error_logger(str(request.user), " SYSTEM_IP_IMPORTER_SYSTEM_EXISTS " + "row_" + str(i) + ":system_exists|system_name:" + row[0] + "|ip:" + str(row[1]))
continue
# create form with request data
form = SystemIpFileImport(request.POST, request.FILES)
# create system
if form.is_valid():
# don't save form yet
system = form.save(commit=False)
# set system_name
system.system_name = row[0]
# set auto values
system.system_created_by_user_id = request.user
system.system_modified_by_user_id = request.user
system.system_modify_time = timezone.now()
# save object
system.save()
# save manytomany
form.save_m2m()
# save ip for system
system.ip.add(ip)
# call logger
system.logger(str(request.user), ' SYSTEM_IP_IMPORTER_EXECUTED')
# wrong file type
except UnicodeDecodeError:
critical_logger(str(request.user), " SYSTEM_IP_IMPORTER_WRONG_FILE_TYPE")
# call logger
debug_logger(str(request.user), " SYSTEM_IP_IMPORTER_END")
return redirect('/systems')
else:
# show empty form
form = SystemIpFileImport(initial={
'systemstatus': 2,
'analysisstatus': 1,
})
# call logger
debug_logger(str(request.user), " SYSTEM_IP_IMPORTER_ENTERED")
return render(request, 'dfirtrack_main/system/systems_ip_importer.html', {'form': form})
def systems_tags(request):
""" this function imports a csv file with multiple systems and relevant tags """
"""
the following high-level workflow is done by this function
- remove all tags for systems beginning with 'TAGPREFIX' (if there are any)
- evaluate given CSV line by line (without first row)
- check whether this line has relevant tags (leave loop if not)
- get hostname and convert to lowercase
- get domain and change to empty string if incorrect (either 'NT AUTHORITY' or hostname itself)
- create domain if necessary
- check for existing systems (with this hostname)
- if == 1:
- check for existing domain (for this system)
if domain_of_system == NULL: domain is set to domain from CSV (if there is one)
- if > 1: leave loop because not distinct
- if == 0: create system
- add relevant tags to this system
- check for reportitem headline = SYSTEMTAG_HEADLINE, reportitem_subheadline = SYSTEMTAG_SUBHEADLINE and create if necessary
- fill reportitem_note with markdown table containing with information of report(s)
- logs and messages are written if applicable
- counters are incremented where necessary
"""
# form was valid to post
if request.method == "POST":
# call logger
debug_logger(str(request.user), " SYSTEM_TAG_IMPORTER_BEGIN")
# check TAGLIST (from settings.config) for empty list
if not TAGLIST:
messages.error(request, "No relevant tags defined. Check `TAGLIST` in `dfirtrack.config`!")
# call logger
error_logger(str(request.user), " SYSTEM_TAG_IMPORTER_NO_TAGS_DEFINED.")
return redirect('/systems/')
else:
taglist = TAGLIST
# check TAGPREFIX (from settings.config) for empty string
if TAGPREFIX is "":
messages.error(request, "No prefix string defined. Check `TAGPREFIX` in `dfirtrack.config`!")
# call logger
error_logger(str(request.user), " SYSTEM_TAG_IMPORTER_NO_TAGPREFIX_DEFINED.")
return redirect('/systems/')
# expand the string by an underscore
else:
tagprefix = TAGPREFIX + "_"
# check whether SYSTEMTAG_HEADLINE is defined in `dfirtrack.config`
if systemtag_headline == '':
# call logger
error_logger(str(request.user), " SYSTEMTAG_HEADLINE_VARIABLE_UNDEFINED")
messages.error(request, "The variable SYSTEMTAG_HEADLINE seems to be undefined. Check `dfirtrack.config`!")
# leave importer
return redirect('/systems/')
# check whether SYSTEMTAG_SUBHEADLINE is defined in `dfirtrack.config`
if systemtag_subheadline == '':
# call logger
error_logger(str(request.user), " SYSTEMTAG_SUBHEADLINE_VARIABLE_UNDEFINED")
messages.error(request, "The variable SYSTEMTAG_SUBHEADLINE seems to be undefined. Check `dfirtrack.config`!")
# leave importer
return redirect('/systems/')
# get text out of file (variable results from request object via file upload field)
systemtagcsv = TextIOWrapper(request.FILES['systemtagcsv'].file, encoding=request.encoding)
# read rows out of csv
rows = csv.reader(systemtagcsv)
# create empty list (this list is used to store every line as single dict: {system_name: row}), because if there are multiple rows with the same system they are added to the same reportitem
rowlist = []
""" remove all tags for systems beginning with 'TAGPREFIX' (if there are any) """
# get all systems that have tags beginning with 'TAGPREFIX' | prefixtagsystems -> queryset
prefixtagsystems=System.objects.filter(tag__tag_name__startswith=tagprefix)
# iterate over systems in queryset | prefixtagsystem -> system object
for prefixtagsystem in prefixtagsystems:
# get all tags beginning with 'TAGPREFIX' that belong to the actual system | systemprefixtags -> queryset
systemprefixtags=prefixtagsystem.tag.filter(tag_name__startswith=tagprefix)
# iterate over queryset | systemprefixtag -> tag object
for systemprefixtag in systemprefixtags:
# delete all existing tags (the m2m relationship) beginning with 'TAGPREFIX' for this system (so that removed tags from csv will be removed as well)
systemprefixtag.system_set.remove(prefixtagsystem)
# create headline if it does not exist
headline, created = Headline.objects.get_or_create(headline_name=systemtag_headline)
if created == True:
headline.logger(str(request.user), " SYSTEMS_TAG_IMPORTER_HEADLINE_CREATED")
""" remove all reportitems """
# delete reportitems (so no reportitems with legacy information / tags will be left)
Reportitem.objects.filter(headline = headline, reportitem_subheadline = systemtag_subheadline).delete()
""" prepare and start loop """
# set row_counter (needed for logger)
row_counter = 1
# set systems_created_counter (needed for messages)
systems_created_counter = 0
# set systems_skipped_counter (needed for messages)
systems_skipped_counter = 0
# iterate over rows
for row in rows:
# skip first row (headlines)
if row_counter == 1:
# autoincrement row counter
row_counter += 1
continue
# get system_name and change to lowercase
system_name = row[8].lower()
# get tags from csv
tagcsvstring = row[9]
if tagcsvstring == '':
# autoincrement systems_skipped_counter
systems_skipped_counter += 1
# autoincrement row_counter
row_counter += 1
# leave because systems without tags are not relevant
continue
else:
# convert string (at whitespaces) to list
tagcsvlist = tagcsvstring.split()
# create empty list for mapping
tagaddlist = []
# check for relevant tags and add to list
for tag in taglist:
if tag in tagcsvlist:
tagaddlist.append(tagprefix + tag)
# check if tagaddlist is empty
if not tagaddlist:
# autoincrement systems_skipped_counter
systems_skipped_counter += 1
# autoincrement row_counter
row_counter += 1
# leave because there are no relevant tags
continue
# get domain from csv
domain_name = row[7]
# change domain_name to empty string if incorrect domain_name ('NT AUTHORITY') was provided
if domain_name == 'NT AUTHORITY':
domain_name = ''
# clear domain if domain_name equals system_name
elif domain_name.lower() == system_name:
domain_name = ''
# get or create domain object if some valid name was provided
if domain_name != '':
# create domain
domain, created = Domain.objects.get_or_create(domain_name=domain_name)
# call logger if created
if created == True:
domain.logger(str(request.user), " SYSTEMS_TAG_IMPORTER_DOMAIN_CREATED")
messages.success(request, 'Domain "' + domain.domain_name + '" created.')
else:
# set domain to None to avoid further errors (domain is needed later)
domain = None
# create empty dict
rowdict = {}
# put the actual row to the dict (dict with only ONE key-value-pair)
rowdict[system_name] = row
# append dict to the global list (because if there are multiple rows with the same system, needed for reportitem SYSTEMTAG_SUBHEADLINE)
rowlist.append(rowdict)
# get all systems with this system_name
systemquery = System.objects.filter(system_name=system_name)
""" check how many systems were returned """
# if there is only one system
if len(systemquery) == 1:
# get system object
system = System.objects.get(system_name=system_name)
""" add domain from CSV only if system does not already has a domain """
# check whether system has existing domain and CSV submitted a domain
if system.domain is None and domain is not None:
# if system has no existing domain set domain of system to domain submitted by tag csv
system.domain = domain
system.system_modify_time = timezone.now()
system.system_modified_by_user_id = request.user
system.save()
# call logger
system.logger(str(request.user), " SYSTEMS_TAG_IMPORTER_SYSTEM_DOMAIN_ADDED")
# if there is more than one system
elif len(systemquery) > 1:
# call logger
error_logger(str(request.user), " SYSTEM_TAG_IMPORTER_SYSTEM_EXISTS_MULTIPLE_TIMES " + "row_" + str(row_counter) + ":system_exists_multiple_times|system_name:" + system_name)
messages.error(request, 'System "' + system_name + '" was found multiple times. Nothing was changed for this system.')
# autoincrement row_counter
row_counter += 1
# leave because of no distinct mapping
continue
else:
# create entire new system object
system = System()
system.system_name = system_name
system.systemstatus = Systemstatus.objects.get(systemstatus_name = "Unknown")
#system.analysisstatus = Analysisstatus.objects.get(analysisstatus_name = "Needs anaylsis")
# add domain if submitted
if domain is not None:
system.domain = domain
system.system_modify_time = timezone.now()
system.system_created_by_user_id = request.user
system.system_modified_by_user_id = request.user
system.save()
# autoincrement systems_created_counter
systems_created_counter += 1
# call logger
system.logger(str(request.user), " SYSTEMS_TAG_IMPORTER_SYSTEM_CREATED")
# iterate over tags in tagaddlist
for tag_name in tagaddlist:
# get tagcolor object
tagcolor = Tagcolor.objects.get(tagcolor_name='primary')
# create tag if needed
tag, created = Tag.objects.get_or_create(tag_name=tag_name, tagcolor=tagcolor)
# call logger if created
if created == True:
tag.logger(str(request.user), " SYSTEMS_TAG_IMPORTER_TAG_CREATED")
messages.success(request, 'Tag "' + tag.tag_name + '" created.')
# add tag to system
tag.system_set.add(system)
# call logger
system.logger(str(request.user), " SYSTEMS_TAG_IMPORTER_SYSTEM_MODIFIED")
# create reportitem if it does not exist (get_or_create won't work in this context because of needed user objects for saving)
try:
reportitem = Reportitem.objects.get(system = system, headline = headline, reportitem_subheadline = systemtag_subheadline)
except Reportitem.DoesNotExist:
reportitem = Reportitem()
reportitem.system = system
reportitem.headline = headline
reportitem.reportitem_subheadline = (systemtag_subheadline)
reportitem.reportitem_created_by_user_id = request.user
# create empty list (used to store elements of markdown table)
notelist = []
# put head of markdown table into list
notelist.append("|File|Type|Version|Started|Duration|Lines|Checked|Domain|Host|Tags|Errors|FirstTrace|LastToolUsage|UsageTime|MalwareInstall")
notelist.append("|:---|:---|:---|:---|:---|:---|:---|:---|:---|:---|:---|:---|:---|:---|:---|")
# iterate over entries in list (dictionaries)
for item in rowlist:
# if this single key-value-pair dict contains the system
if system_name in item:
# get row
entry = item[system_name]
# convert row
entry = "|" + "|".join(entry) + "|"
# fill empty fields with '---' (otherwise mkdocs skips these)
entry = entry.replace("||", "| --- |")
# repeat last step to catch empty fields lying next to each other
entry = entry.replace("||", "| --- |")
# put entry to markdown table
notelist.append(entry)
# join list to string with linebreaks
notestring = "\n".join(notelist)
# add changing values (existing reportitem_note will be overwritten)
reportitem.reportitem_note = notestring
reportitem.reportitem_modified_by_user_id = request.user
reportitem.save()
# call logger
reportitem.logger(str(request.user), " SYSTEMS_TAG_IMPORTER_REPORTITEM_CREATED_OR_MODIFIED")
# autoincrement row_counter
row_counter += 1
# call final messages
if systems_created_counter > 0:
if systems_created_counter == 1:
messages.success(request, str(systems_created_counter) + ' system was created.')
else:
messages.success(request, str(systems_created_counter) + ' systems were created.')
if systems_skipped_counter > 0:
if systems_skipped_counter == 1:
messages.warning(request, str(systems_skipped_counter) + ' system was skipped or cleaned (no relevant tags).')
else:
messages.warning(request, str(systems_skipped_counter) + ' systems were skipped or cleaned (no relevant tags).')
# call logger
debug_logger(str(request.user), " SYSTEM_TAG_IMPORTER_END")
return redirect('/systems/')
else:
# show empty form
form = SystemTagFileImport()
# call logger
debug_logger(str(request.user), " SYSTEM_TAG_IMPORTER_ENTERED")
return render(request, 'dfirtrack_main/system/systems_tag_importer.html', {'form': form})
def entry(request):
# get user string
request_user = str(request.user)
# get redirector from GET request
redirector = request.GET['redirector']
# call logger
debug_logger(request_user, " API_GIRAF_ENTRIES_BEGIN")
# check variables in `dfirtrack.config`
stop_importer_api_giraf = check_config(request)
# leave importer_api_giraf if variables caused errors
if stop_importer_api_giraf:
return redirect(reverse('system_list'))
# check connection
try:
urllib.request.urlopen(dfirtrack_config.GIRAF_URL, timeout=2)
except:
# call logger
error_logger(request_user, " API_GIRAF_ENTRIES_URL_NOT_AVAILABLE")
messages.error(request, "GIRAF API URL not available.")
# call logger (for consistency purposes to show end of api call)
debug_logger(request_user, " API_GIRAF_SYSTEMS_END")
if redirector == 'entry':
return redirect(reverse('entry_list'))
elif redirector == 'system':
return redirect(reverse('system_list'))
# get JSON from GIRAF API (returns <class 'requests.models.Response'>)
entry_json = requests.get(
dfirtrack_config.GIRAF_URL + '/api/systems/timelines/',
auth=(dfirtrack_config.GIRAF_USER, dfirtrack_config.GIRAF_PASS))
# load JSON to list (returns list if authenticated, returns dict else)
entry_list = entry_json.json()
# check for list type (in case of auth error it returns dict)
if type(entry_list) != list:
""" stop api call because of missing list """
# call logger
error_logger(request_user, " API_GIRAF_POSSIBLE_AUTH_ERROR")
messages.error(request, "GIRAF API possible authentication error.")
# call logger (for consistency purposes to show end of api call)
debug_logger(request_user, " API_GIRAF_ENTRIES_END")
# redirect depending on redirector from GET request
if redirector == 'entry':
return redirect(reverse('entry_list'))
elif redirector == 'system':
return redirect(reverse('system_list'))
# iterate over entries
for entry_dict in entry_list:
# get entry time
entry_time = entry_dict['entry_date']
if entry_time is not None:
entry_time = dateutil.parser.parse(entry_time)
# get system
entry_system_dict = entry_dict['system']
system_uuid = entry_system_dict['uuid']
try:
system = System.objects.get(system_uuid=system_uuid)
except:
# call logger
error_logger(
request_user, " API_GIRAF_ENTRIES_UNKNOWN_SYSTEM " +
"system_uuid:" + system_uuid)
messages.error(request,
"GIRAF API unknown system UUID: " + system_uuid)
# leave this loop because system for this entry does not exist yet
continue
# get entry sha1
entry_sha1 = entry_dict['hash_sha1']
# get entry content
entry_content = entry_dict['json_content']
# load JSON to dict
entry_content = json.loads(entry_content)
# extract entry content from dict
entry_date = entry_content['date']
entry_utc = entry_content['utc']
entry_system = entry_content['system']
entry_type = entry_content['type']
entry_content = entry_content['content']
# get entry if it already exists
entry = Entry.objects.filter(system=system, entry_sha1=entry_sha1)
# only create object if it does not exist yet
if not entry:
# create new entry object
entry = Entry()
# enter extracted values
entry.entry_time = entry_time
entry.system = system
entry.entry_sha1 = entry_sha1
entry.entry_date = entry_date
entry.entry_utc = entry_utc
entry.entry_system = entry_system
entry.entry_type = entry_type
entry.entry_content = entry_content
# set auto values
entry.entry_create_time = timezone.now()
entry.entry_modify_time = timezone.now()
entry.entry_api_time = timezone.now()
entry.entry_created_by_user_id = request.user
entry.entry_modified_by_user_id = request.user
# save object
entry.save()
# call logger
entry.logger(request_user, ' API_GIRAF_ENTRIES_EXECUTED')
# call logger
debug_logger(request_user, " API_GIRAF_ENTRIES_END")
# redirect depending on redirector from GET request
if redirector == 'entry':
return redirect(reverse('entry_list'))
elif redirector == 'system':
return redirect(reverse('system_list'))
def check_content_file_system(main_config_model, module_text, request=None):
"""check file system"""
# reset stop condition
stop_cron_exporter = False
""" set username for logger """
# if function was called from 'artifact_create_cron' / 'system_create_cron'
if request:
logger_username = str(request.user)
# if function was called from 'artifact_cron' / 'system_cron'
else:
logger_username = main_config_model.cron_username
# cron export path does not exist - stop immediately
if not os.path.isdir(main_config_model.cron_export_path):
# if function was called from 'artifact_create_cron' / 'system_create_cron'
if request:
# call message
messages.error(
request,
'Export path does not exist. Check config or file system!')
# if function was called from 'artifact_cron' / 'system_cron'
else:
# call message for all users
error_message_cron(
f'{module_text}: Export path does not exist. Check config or file system!'
)
# call logger
error_logger(
logger_username,
f' {module_text}_SPREADSHEET_EXPORTER_CRON_EXPORT_PATH_NOT_EXISTING',
)
# set stop condition
stop_cron_exporter = True
else:
# no write permission for cron export path - stop immediately
if not os.access(main_config_model.cron_export_path, os.R_OK):
# if function was called from 'artifact_create_cron' / 'system_create_cron'
if request:
# call message
messages.error(
request,
'No write permission for export path. Check config or file system!',
)
# if function was called from 'artifact_cron' / 'system_cron'
else:
# call message for all users
error_message_cron(
f'{module_text}: No write permission for export path. Check config or file system!'
)
# call logger
error_logger(
logger_username,
f' {module_text}_SPREADSHEET_EXPORTER_CRON_EXPORT_PATH_NO_WRITE_PERMISSION',
)
# set stop condition
stop_cron_exporter = True
# return stop condition
return stop_cron_exporter
