def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, TraceModel.required)
json_dict['__python_obj__'] = Trace.__module__ + '.' + Trace.__name__
tr = json_serialize(json_dict)
tr = json_deserialize(tr)
if isinstance(tr, Trace):
return tr
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request, to_props=False):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, ExternalDocumentModel.required)
json_dict['__python_obj__'] = ExternalDocument.__module__+'.'+ ExternalDocument.__name__
edoc = json_serialize(json_dict)
edoc = json_deserialize(edoc)
if isinstance(edoc, ExternalDocument):
return edoc
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request, to_props=False):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, PolicyStatementModel.required)
json_dict['__python_obj__'] = PolicyStatement.__module__+'.'+ PolicyStatement.__name__
ps = json_serialize(json_dict)
ps = json_deserialize(ps)
if isinstance(ps, PolicyStatement):
return ps
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, DomainPropertyModel.required)
json_dict['__python_obj__'] = DomainProperty.__module__ + '.' + DomainProperty.__name__
domain_property = json_serialize(json_dict)
domain_property = json_deserialize(domain_property)
if not isinstance(domain_property, DomainProperty):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return domain_property
def type_from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, ValueTypeModel.required)
json_dict['__python_obj__'] = ValueType.__module__+'.'+ValueType.__name__
value_type = json_serialize(json_dict)
value_type = json_deserialize(value_type)
if not isinstance(value_type, ValueType):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return value_type
def from_json(self, request, to_props=False):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, ConceptReferenceModel.required)
json_dict[
'__python_obj__'] = ConceptReference.__module__ + '.' + ConceptReference.__name__
cr = json_serialize(json_dict)
cr = json_deserialize(cr)
if isinstance(cr, ConceptReference):
return cr
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request, to_props=False):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, TemplateGoalModel.required)
json_dict[
'__python_obj__'] = TemplateGoal.__module__ + '.' + TemplateGoal.__name__
tg = json_serialize(json_dict)
tg = json_deserialize(tg)
if isinstance(tg, TemplateGoal):
return tg
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request, to_props=False):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, ReferenceSynopsisModel.required)
json_dict[
'__python_obj__'] = ReferenceSynopsis.__module__ + '.' + ReferenceSynopsis.__name__
ug = json_serialize(json_dict)
ug = json_deserialize(ug)
if isinstance(ug, ReferenceSynopsis):
return ug
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request, to_props=False):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, UserStoryModel.required)
json_dict[
'__python_obj__'] = UserStory.__module__ + '.' + UserStory.__name__
us = json_serialize(json_dict)
us = json_deserialize(us)
if isinstance(us, UserStory):
return us
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request, to_props=False):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, PersonaCharacteristicModel.required)
json_dict['__python_obj__'] = PersonaCharacteristic.__module__+'.'+ PersonaCharacteristic.__name__
pc = json_serialize(json_dict)
pc = json_deserialize(pc)
pc,ps,rss,rcs = self.convert_pcrs(fake_pc=pc)
if isinstance(pc, PersonaCharacteristic):
return pc,ps,rss,rcs
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request, to_props=False):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, GoalAssociationModel.required)
json_dict[
'__python_obj__'] = GoalAssociation.__module__ + '.' + GoalAssociation.__name__
assoc = json_serialize(json_dict)
assoc = json_deserialize(assoc)
if isinstance(assoc, GoalAssociation):
return assoc
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request):
"""
:rtype Role
"""
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, RoleModel.required)
json_dict['__python_obj__'] = Role.__module__+'.'+Role.__name__
role = json_serialize(json_dict)
role = json_deserialize(role)
if not isinstance(role, Role):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return role
def from_json(self, request, to_props=False):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, TaskCharacteristicModel.required)
json_dict[
'__python_obj__'] = TaskCharacteristic.__module__ + '.' + TaskCharacteristic.__name__
tc = json_serialize(json_dict)
tc = json_deserialize(tc)
tc = self.convert_tcrs(fake_tc=tc)
if isinstance(tc, TaskCharacteristic):
return tc
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request):
json_dict = super(DependencyDAO, self).from_json(request)
check_required_keys(json_dict, DependencyModel.required)
json_dict[
'__python_obj__'] = Dependency.__module__ + '.' + Dependency.__name__
dependency = json_deserialize(json_dict)
if isinstance(dependency, Dependency):
return dependency
else:
self.close()
raise MalformedJSONHTTPError(json_serialize(json_dict))
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, TrustBoundaryModel.required)
json_dict['__python_obj__'] = TrustBoundary.__module__ + '.' + TrustBoundary.__name__
env_props = self.convert_props(fake_props=json_dict['theEnvironmentProperties'])
json_dict['theEnvironmentProperties'] = []
tb = json_serialize(json_dict)
tb = json_deserialize(tb)
tb.theEnvironmentProperties = env_props
if not isinstance(tb, TrustBoundary):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return tb
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, CountermeasureModel.required)
json_dict['__python_obj__'] = Countermeasure.__module__ + '.' + Countermeasure.__name__
countermeasure_props = self.convert_props(fake_props=json_dict['theEnvironmentProperties'])
json_dict['theEnvironmentProperties'] = []
countermeasure = json_serialize(json_dict)
countermeasure = json_deserialize(countermeasure)
countermeasure.theEnvironmentProperties = countermeasure_props
if not isinstance(countermeasure, Countermeasure):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return countermeasure
def from_json(self, request):
"""
:rtype : DataFlow
:raise MalformedJSONHTTPError:
"""
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, DataFlowModel.required)
json_dict[
'__python_obj__'] = DataFlow.__module__ + '.' + DataFlow.__name__
dataflow = json_serialize(json_dict)
dataflow = json_deserialize(dataflow)
if not isinstance(dataflow, DataFlow):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return dataflow
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, GoalModel.required)
json_dict['__python_obj__'] = Goal.__module__+'.'+Goal.__name__
props_list = json_dict.pop('theEnvironmentProperties', [])
json_dict.pop('theEnvironmentDictionary', None)
real_props = self.convert_properties(json_dict['theName'],fake_props=props_list)
new_json_goal = json_serialize(json_dict)
new_json_goal = json_deserialize(new_json_goal)
new_json_goal.theEnvironmentProperties = real_props
if not isinstance(new_json_goal, Goal):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return new_json_goal
def from_json(self, request, to_props=False):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, TemplateAssetModel.required)
json_dict[
'__python_obj__'] = TemplateAsset.__module__ + '.' + TemplateAsset.__name__
ifs = json_dict.pop('theInterfaces', [])
ifs = self.convert_ifs(fake_ifs=ifs)
ta = json_serialize(json_dict)
ta = json_deserialize(ta)
if isinstance(ta, TemplateAsset):
ta.theInterfaces = ifs
return ta
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request, to_props=False):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, AssetModel.required)
json_dict['__python_obj__'] = Asset.__module__+'.'+Asset.__name__
env_props = json_dict.pop('theEnvironmentProperties', [])
env_props = self.convert_props(fake_props=env_props)
json_dict.pop('theEnvironmentDictionary', None)
json_dict.pop('theAssetPropertyDictionary', None)
asset = json_serialize(json_dict)
asset = json_deserialize(asset)
if isinstance(asset, Asset):
asset.theEnvironmentProperties = env_props
return asset
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, PersonaModel.required)
json_dict[
'__python_obj__'] = Persona.__module__ + '.' + Persona.__name__
persona_props = self.convert_props(
fake_props=json_dict['theEnvironmentProperties'])
json_dict['theEnvironmentProperties'] = []
persona = json_serialize(json_dict)
persona = json_deserialize(persona)
persona.theEnvironmentProperties = persona_props
if not isinstance(persona, Persona):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return persona
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, VulnerabilityModel.required)
json_dict['__python_obj__'] = Vulnerability.__module__+'.'+Vulnerability.__name__
for idx in range(0, len(json_dict['theEnvironmentProperties'])):
property = json_dict['theEnvironmentProperties'][idx]
check_required_keys(property, VulnerabilityEnvironmentPropertiesModel.required)
property['__python_obj__'] = VulnerabilityEnvironmentProperties.__module__+'.'+VulnerabilityEnvironmentProperties.__name__
json_dict['theEnvironmentProperties'][idx] = property
vulnerability = json_serialize(json_dict)
vulnerability = json_deserialize(vulnerability)
if not isinstance(vulnerability, Vulnerability):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return vulnerability
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, AttackerModel.required)
json_dict[
'__python_obj__'] = Attacker.__module__ + '.' + Attacker.__name__
attacker_props = self.convert_props(
fake_props=json_dict['theEnvironmentProperties'])
json_dict['theEnvironmentProperties'] = []
attacker = json_serialize(json_dict)
attacker = json_deserialize(attacker)
attacker.theEnvironmentProperties = attacker_props
if not isinstance(attacker, Attacker):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return attacker
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, LocationsModel.required)
json_dict['__python_obj__'] = Locations.__module__+'.'+ Locations.__name__
loc_list = self.convert_loc_list(fake_loc_list=json_dict['theLocations'])
json_dict['theLocations'] = []
locs = json_serialize(json_dict)
locs = json_deserialize(locs)
locs.theLocations = loc_list
locs.theLinks = []
if isinstance(locs, Locations):
return locs
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request):
self.logger.debug('Request data: %s', request.data)
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, ObstacleModel.required)
json_dict['__python_obj__'] = Obstacle.__module__+'.'+Obstacle.__name__
props_list = json_dict.pop('theEnvironmentProperties', [])
json_dict.pop('theEnvironmentDictionary', None)
real_props = self.convert_properties(fake_props=props_list)
new_json_obstacle = json_serialize(json_dict)
new_json_obstacle = json_deserialize(new_json_obstacle)
new_json_obstacle.theEnvironmentProperties = real_props
if not isinstance(new_json_obstacle, Obstacle):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return new_json_obstacle
def from_json(self, request):
"""
:rtype : UseCase
:raise MalformedJSONHTTPError:
"""
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, UseCaseModel.required)
json_dict[
'__python_obj__'] = UseCase.__module__ + '.' + UseCase.__name__
usecase_props = self.convert_props(
fake_props=json_dict['theEnvironmentProperties'])
json_dict['theEnvironmentProperties'] = []
usecase = json_serialize(json_dict)
usecase = json_deserialize(usecase)
usecase.theEnvironmentProperties = usecase_props
if not isinstance(usecase, UseCase):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
frcs = json_dict['theReferenceContributions']
refContribs = []
for frc in frcs:
refContribs.append(
ReferenceContribution(
usecase.theName, frc['theContributionTo'],
frc['theReferenceContribution']['theMeansEnd'],
frc['theReferenceContribution']['theContribution']))
return usecase, refContribs
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, ProjectSettings.required)
json_dict[
'__python_obj__'] = ProjectSettings.__module__ + '.' + ProjectSettings.__name__
contrs = json_dict['contributions'] or []
if not isinstance(contrs, list):
contrs = []
for idx in range(0, len(contrs)):
try:
check_required_keys(contrs[idx], Contributor.required)
json_dict['contributions'][idx] = (contrs[idx]['firstName'],
contrs[idx]['surname'],
contrs[idx]['affiliation'],
contrs[idx]['role'])
except MissingParameterHTTPError:
SilentHTTPError(
'A contribution did not contain all required fields. Skipping this one.'
)
revisions = json_dict['revisions'] or []
if not isinstance(revisions, list):
revisions = []
for idx in range(0, len(revisions)):
try:
check_required_keys(revisions[idx], Revision.required)
json_dict['revisions'][idx] = (revisions[idx]['id'],
revisions[idx]['date'],
revisions[idx]['description'])
except MissingParameterHTTPError:
SilentHTTPError(
'A revision did not contain all required fields. Skipping this one.'
)
json_dict['definitions'] = json_dict.get('definitions', None) or {}
json_dict['definitions'] = list(json_dict['definitions'].items())
settings = json_deserialize(json_dict)
return settings
def post(self):
session_id = get_session_id(session, request)
json_dict = request.get_json(silent=True)
if json_dict is False or json_dict is None:
raise MalformedJSONHTTPError(data=request.get_data())
cimport_params = json_dict.get('object', None)
check_required_keys(cimport_params or {}, CImportParams.required)
file_contents = cimport_params['urlenc_file_contents']
file_contents = unquote(file_contents)
type = cimport_params['type']
if file_contents.startswith('<?xml'):
fd, abs_path = mkstemp(suffix='.xml')
fs_temp = open(abs_path, 'w')
fs_temp.write(file_contents)
fs_temp.close()
fd_close(fd)
try:
dao = ImportDAO(session_id)
result = dao.file_import(abs_path, type, 1)
dao.close()
except DatabaseProxyException as ex:
raise ARMHTTPError(ex)
except ARMException as ex:
raise ARMHTTPError(ex)
except Exception as ex:
raise CairisHTTPError(status_code=500,message=str(ex.message),status='Unknown error')
remove_file(abs_path)
resp_dict = {'message': str(result)}
resp = make_response(json_serialize(resp_dict, session_id=session_id), httplib.OK)
resp.headers['Content-Type'] = 'application/json'
return resp
else:
raise CairisHTTPError(status_code=httplib.BAD_REQUEST,message='The provided file is not a valid XML file',status='Invalid XML input')
def convert_props(self,
real_props=None,
fake_props=None,
response_type=None):
response_type = response_type.lower()
if real_props:
if response_type in ('prevent', 'detect', 'deter', 'react'):
response_type = 'mitigate'
new_props_list = []
for idx in range(0, len(real_props)):
real_prop = real_props[idx]
if isinstance(real_prop, AcceptEnvironmentProperties
) and response_type == 'accept':
new_props_list.append(real_prop)
elif isinstance(real_prop, MitigateEnvironmentProperties
) and response_type == 'mitigate':
new_props_list.append(real_prop)
elif isinstance(real_prop, TransferEnvironmentProperties
) and response_type == 'transfer':
roles = real_prop.theRoles
for idx in range(0, len(roles)):
roles[idx] = ValuedRole(roles[idx][0], roles[idx][1])
real_prop.theRoles = roles
new_props_list.append(real_prop)
new_props = {response_type: new_props_list}
elif fake_props:
new_props = []
if (response_type in ['Prevent', 'Deter', 'Detect', 'React']):
response_type = 'mitigate'
if not (response_type
in ResponseEnvironmentPropertiesModel.field_names):
raise MalformedJSONHTTPError()
if response_type == 'accept':
model_class = AcceptEnvironmentPropertiesModel
target_class = AcceptEnvironmentProperties
elif response_type == 'mitigate':
model_class = MitigateEnvironmentPropertiesModel
target_class = MitigateEnvironmentProperties
elif response_type == 'transfer':
model_class = TransferEnvironmentPropertiesModel
target_class = TransferEnvironmentProperties
else:
raise MalformedJSONHTTPError()
for fake_prop_key in fake_props:
fake_prop_list = fake_props[fake_prop_key]
if (len(fake_prop_list) > 0):
for fake_prop in fake_prop_list:
check_required_keys(fake_prop, model_class.required)
fake_prop[
'__python_obj__'] = target_class.__module__ + '.' + target_class.__name__
if target_class is TransferEnvironmentProperties:
roles = []
if isinstance(fake_prop['theRoles'], list):
for role in fake_prop['theRoles']:
check_required_keys(
role, ValuedRole.required)
roles.append(
(role['roleName'], role['cost']))
fake_prop['theRoles'] = roles
new_props.append(fake_prop)
else:
self.close()
raise MalformedJSONHTTPError()
return new_props
def json_deserialize(string, class_name=None):
"""
Deserializes the JSON object to the appropriate class instance.
:param string: The JSON string
:type string: str
:param class_name: The name of the target class
:type class_name: str
:return: Returns a dictionary or a class instance depending on the target class chosen
:rtype: list|dict|Asset|Goal|Requirement|Risk
"""
if isinstance(string, dict) or isinstance(string, list):
string = json_serialize(string)
if isinstance(string, list):
list_result = []
for item_string in string:
item_string = json_serialize(item_string)
for key in conv_terms:
item_string = item_string.replace(conv_terms[key], key)
list_result.append(json_deserialize(item_string))
if isinstance(string, string_types):
for key in conv_terms:
string = string.replace(conv_terms[key], key)
try:
obj = deserialize(string)
if isinstance(obj, Environment):
tensions = {}
for key, value in list(obj.theTensions.items()):
key = str(key)
attrs = key.strip('(').strip(')').split(',')
if len(attrs) == 2:
idx1 = int(attrs[0].strip(' '))
idx2 = int(attrs[1].strip(' '))
tuple_key = (idx1, idx2)
tensions[tuple_key] = value
obj = Environment(
id=obj.theId,
name=obj.theName,
sc=obj.theShortCode,
description=obj.theDescription,
environments=obj.theEnvironments,
duplProperty=obj.theDuplicateProperty,
overridingEnvironment=obj.theOverridingEnvironment,
envTensions=tensions)
if isinstance(obj, dict):
if class_name == 'asset':
from cairis.daemon.CairisHTTPError import MalformedJSONHTTPError
raise MalformedJSONHTTPError()
elif class_name == 'goal':
obj = deserialize_goal(dict)
elif class_name == 'requirement':
obj = deserialize_requirement(dict)
return obj
except Exception as ex:
from cairis.daemon.CairisHTTPError import handle_exception
handle_exception(ex)
