def send_data(self):
try:
servicenw_user = Servicenowmodel.objects.filter(
source_id__user_id=self.request.user).first()
servicenw_flag = servicenw_user and servicenw_user.flag
if servicenw_flag:
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
url, username, password, options_str = servicenw_user.url, servicenw_user.username, servicenw_user.password, servicenw_user.config
options_formatted = options_str.replace("'", '"')
options = json.loads(options_formatted)
snw_obj = ServiceNowEvents(url, username, password)
snw_response = collect_events(access_key, domain, **options)
data = self.process_ssc_response(snw_response)
for each_record in data:
current_time = str(datetime.datetime.now())
msg = "New SecurityScorecard Issue is reported on {}.".format(
current_time)
servicenow_payload["short_description"] = msg
servicenow_payload['description'] = json.dumps(
each_record[0])
fresh_resp = snw_obj.create_incident(**servicenow_payload)
# snw_resp = snw_obj.create_incident(**each_record[0])
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def send_data(self):
try:
agilecrm_user = Agilecrmmodel.objects.filter(
source_id__user_id=self.request.user).first()
agilecrm_flag = agilecrm_user and agilecrm_user.flag
if agilecrm_flag:
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
app_url, username, api_key, options_str = agilecrm_user.url, agilecrm_user.username, agilecrm_user.api_key, agilecrm_user.config,
options_formatted = options_str.replace("'", '"')
options = json.loads(options_formatted)
agilecrm_obj = AgilecrmEvents(username, api_key, app_url)
agilecrm_response = collect_events(access_key, domain,
**options)
data = self.process_ssc_response(agilecrm_response)
for each_record in data:
current_time = str(datetime.datetime.now())
msg = "New SecurityScorecard Issue is reported on {}.".format(
current_time)
agilecrm_payload["subject"] = msg
agilecrm_payload[
"requester_email"] = self.request.user.email
agilecrm_payload['name'] = self.request.user.first_name
agilecrm_payload['html_text'] = json.dumps(each_record[0])
fresh_resp = agilecrm_obj.create_incident(
**agilecrm_payload)
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def send_data(self):
try:
jira_user = models.Jira.objects.filter(
user_id=self.request.user).first()
jira_flag = jira_user and jira_user.flag
if jira_flag:
url, username, api_token, options_str = jira_user.app_url, jira_user.email_id, jira_user.api_key, jira_user.jira_config
options_formatted = options_str.replace("'", '"')
options = json.loads(options_formatted)
jira_obj = views.Connector(url, username, api_token)
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
sc_jira_response = collect_events(access_key, domain,
**options)
data = self.process_ssc_response(sc_jira_response)
logger.info("Jira is start creating issues%s ",
self.request.user.email)
for each_record in data:
current_time = str(datetime.datetime.now())
msg = "New SecurityScorecard Issue is reported on {}.".format(
current_time)
payload["fields"]["summary"] = msg
payload["fields"]['description']['content'][0]['content'][
0]['text'] = json.dumps(each_record[0])
jira_resp = jira_obj.create_issue(**payload)
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def ssc_test(request):
try:
token = request.POST.get('api_token',None)
domain = request.POST.get('domain',None)
options = {"fetch_company_overall":True}
sc_response = collect_events(token, domain, **options)
if sc_response['overall_resp'] is not None:
return HttpResponse("Success")
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def send_scheduled_alert():
from django.contrib.auth.models import User
from Jira.models import Jira
from Slack.models import Slack
from Slack.utils import send_message_to_slack, dict_to_message
from Jira.views import Connector
from .models import SSCConnector
from .config import payload
users = User.objects.all()
for user in users:
ssc = SSCConnector.objects.filter(user_id=user).first()
slack = Slack.objects.filter(source_id__user_id=user).first()
jira = Jira.objects.filter(user_id=user).first()
slack_flag = slack and slack.flag
jira_flag = jira and jira.flag
ssc_flag = ssc and ssc.flag
if ssc_flag and (slack_flag or jira_flag):
access_key, base_url, domain = ssc.api_token, ssc.api_url, ssc.domain
sc_response = collect_events(access_key, domain)
for security_factor in sc_response:
for each_json in sc_response[security_factor]:
if isinstance(each_json, list):
for each in each_json:
if jira_flag:
url, username, api_token = jira.app_url, jira.email_id, jira.api_key
jira_obj = Connector(url, username, api_token)
payload["fields"]['description']['content'][0][
'content'][0]['text'] = json.dumps(each)
jira_resp = jira_obj.create_issue(**payload)
if slack:
send_message_to_slack(
token=slack.auth_token,
channel=slack.default_channel,
message=each)
else:
if jira_flag:
url, username, api_token = jira.app_url, jira.email_id, jira.api_key
jira_obj = Connector(url, username, api_token)
payload["fields"]['description']['content'][0][
'content'][0]['text'] = json.dumps(each_json)
# jira_resp = jira_obj.create_issue(**payload)
if slack:
send_message_to_slack(
token=slack.auth_token,
channel=slack.default_channel,
message=each_json)
def send_data(self):
try:
rapid_user = Rapid.objects.filter(source_id__user_id = self.request.user).first()
rapid_flag = rapid_user and rapid_user.flag
if rapid_flag:
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
url, token, options_str = rapid_user.url, rapid_user.api_key, rapid_user.config
options_formatted = options_str.replace("'", '"')
options = json.loads(options_formatted)
rapid_obj = Rapidseven(url, token)
rapid_response = collect_events(access_key, domain, **options)
data = self.process_ssc_response(rapid_response)
for each_record in data:
rapid_resp = rapid_obj.create_log(each_record[0])
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def send_data(self):
try:
jitbit_user = Jitbitmodel.objects.filter(
source_id__user_id=self.request.user).first()
jitbit_flag = jitbit_user and jitbit_user.flag
if jitbit_flag:
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
email, password, url, categoryid, options_str = jitbit_user.username, jitbit_user.password, jitbit_user.domain, jitbit_user.categoryId, jitbit_user.config,
options_formatted = options_str.replace("'", '"')
options = json.loads(options_formatted)
jitbit_obj = Jitbitticket(email, password, categoryid, url)
jitbit_response = collect_events(access_key, domain, **options)
data = self.process_ssc_response(jitbit_response)
for each_record in data:
jitbit_resp = jitbit_obj.create_ticket(str(each_record[0]))
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def send_data(self):
try:
zohodesk_user = Zohomodel.objects.filter(
source_id__user_id=self.request.user).first()
zohodesk_flag = zohodesk_user and zohodesk_user.flag
if zohodesk_flag:
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
token, contact_id, department_id, org_id, options_str = zohodesk_user.token, zohodesk_user.contact_id, zohodesk_user.department_id, zohodesk_user.org_id, zohodesk_user.config,
options_formatted = options_str.replace("'", '"')
options = json.loads(options_formatted)
zoho_obj = ZohodeskEvents(contact_id, department_id, token,
org_id)
zoho_response = collect_events(access_key, domain, **options)
data = self.process_ssc_response(zoho_response)
for each_record in data:
zoho_resp = zoho_obj.create_ticket(**each_record[0])
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def send_data(self):
try:
pagerduty_user = Pagerdutymodel.objects.filter(
source_id__user_id=self.request.user).first()
pagerduty_flag = pagerduty_user and pagerduty_user.flag
if pagerduty_flag:
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
email, api_key, service_id, options_str = pagerduty_user.email, pagerduty_user.api_key, pagerduty_user.service_id, pagerduty_user.config,
options_formatted = options_str.replace("'", '"')
options = json.loads(options_formatted)
pagerduty_obj = Pagerdutyincident(email, api_key, service_id)
pagerduty_response = collect_events(access_key, domain,
**options)
data = self.process_ssc_response(pagerduty_response)
for each_record in data:
fresh_resp = pagerduty_obj.create_incident(
str(each_record[0]))
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def send_data(self):
try:
opsgenie_user = Opsgeniemodel.objects.filter(
source_id__user_id=self.ssc_user.user).first()
opsgenie_flag = opsgenie_user and opsgenie_user.flag
if opsgenie_flag:
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
api_key, service_id, options_str = opsgenie_user.api_key, opsgenie_user.service_id, opsgenie_user.config,
options_formatted = options_str.replace("'", '"')
options = json.loads(options_formatted)
opsgenie_obj = Opsgenieincident(api_key, service_id)
opsgenie_response = collect_events(access_key, domain,
**options)
data = self.process_ssc_response(opsgenie_response)
for each_record in data:
opsgenie_resp = opsgenie_obj.create_incident(
str(each_record[0]))
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def send_data(self):
try:
zendesk_user = Zendeskmodel.objects.filter(
source_id__user_id=self.request.user).first()
zendesk_flag = zendesk_user and zendesk_user.flag
if zendesk_flag:
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
api_key, email, url, options_str = zendesk_user.api_key, zendesk_user.email, zendesk_user.url, zendesk_user.config,
options_formatted = options_str.replace("'", '"')
options = json.loads(options_formatted)
zendesk_obj = Zendesktickets(email, api_key, url)
zendesk_response = collect_events(access_key, domain,
**options)
data = self.process_ssc_response(zendesk_response)
for each_record in data:
zendesk_resp = zendesk_obj.create_tickets(
str(each_record[0]))
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def send_data(self):
try:
hubspot_user = Hubspotmodel.objects.filter(source_id__user_id = self.request.user).first()
hubspot_flag = hubspot_user and hubspot_user.flag
if hubspot_flag:
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
api_key, options_str = hubspot_user.api_key, hubspot_user.config,
options_formatted = options_str.replace("'", '"')
options = json.loads(options_formatted)
hubspot_obj = HubspotEvents(api_key)
hubspot_response = collect_events(access_key, domain, **options)
data = self.process_ssc_response(hubspot_response)
for each_record in data:
current_time = str(datetime.datetime.now())
msg = "New SecurityScorecard Issue is reported on {}.".format(current_time)
hubspot_payload[0]["value"] = msg
hubspot_payload[1]["value"] = json.dumps(each_record[0])
fresh_resp = hubspot_obj.create_incident(*hubspot_payload)
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def send_data(self):
try:
slack_user = Slack.objects.filter(
source_id__user_id=self.request.user).first()
slack_flag = slack_user and slack_user.flag
if slack_flag:
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
options_str = slack_user.config
options_formatted = options_str.replace("'", '"')
optionss = json.loads(options_formatted)
sc_slack_response = collect_events(access_key, domain,
**optionss)
data = self.process_ssc_response(sc_slack_response)
logger.info("to Slack is start sending messages%s ",
self.request.user.email)
for each_record in data:
send_message_to_slack(token=slack_user.auth_token,
channel=slack_user.default_channel,
message=each_record[0])
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def send_data(self):
try:
splunk_user = Splunk.objects.filter(
source_id__user_id=self.request.user).first()
splunk_flag = splunk_user and splunk_user.flag
if splunk_flag:
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
url, token, config = splunk_user.api_url, splunk_user.hec_token, splunk_user.config
options_formatted = config.replace("'", '"')
options = json.loads(options_formatted)
sc_splunk_response = collect_events(access_key, domain,
**options)
data = self.process_ssc_response(sc_splunk_response)
splunk_obj = SplunkEvents(token, url)
sp = dict()
for each_record in data:
current_time = str(datetime.datetime.now())
sp['event'] = json.loads(json.dumps(each_record[0]))
splunk_resp = splunk_obj.create_event(json.dumps(sp))
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def send_data(self):
try:
salesforce_user = Salesforcemodel.objects.filter(
source_id__user_id=self.request.user).first()
salesforce_flag = salesforce_user and salesforce_user.flag
if salesforce_flag:
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
url, username, password, client_id, client_secret, secret_token, options_str = salesforce_user.url, salesforce_user.username, salesforce_user.passord, salesforce_user.client_id, salesforce_user.client_secret, salesforce_user.secret_token, salesforce_user.config,
options_formatted = options_str.replace("'", '"')
options = json.loads(options_formatted)
salesforce_obj = Salesforceevents(url, username, password,
client_id, client_secret,
secret_token)
salesforce_response = collect_events(access_key, domain,
**options)
data = self.process_ssc_response(salesforce_response)
for each_record in data:
fresh_resp = salesforce_obj.create_incident(
**each_record[0])
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
def send_data(self):
try:
solarwinds_user = SolarWindsmodel.objects.filter(source_id__user_id = self.request.user).first()
solarwinds_flag = solarwinds_user and solarwinds_user.flag
if solarwinds_flag:
access_key, base_url, domain = self.ssc_user.api_token, self.ssc_user.api_url, self.ssc_user.domain
username, api_key, url, options_str = solarwinds_user.username, solarwinds_user.api_key, solarwinds_user.url, solarwinds_user.config,
options_formatted = options_str.replace("'", '"')
options = json.loads(options_formatted)
solarwinds_obj = SolarWindsEvents(username, api_key, url)
solarwinds_response = collect_events(access_key, domain, **options)
data = self.process_ssc_response(solarwinds_response)
for each_record in data:
current_time = str(datetime.datetime.now())
msg = "New SecurityScorecard Issue is reported on {}.".format(current_time)
solarwinds_payload["incident"]["name"] = msg
solarwinds_payload["incident"]["priority"] = "Critical"
solarwinds_payload["incident"]['description'] = json.dumps(each_record[0])
solarwinds_payload["incident"]["requester"]["email"] = self.request.user.email
fresh_resp = solarwinds_obj.create_incident(**solarwinds_payload)
except Exception as e:
logger.error("Unexpected Exception occured: %s ", e)
return e
