Esempio n. 1
0
 def delete_database(self, db_name, pathValues=[]):
     try:
         if (db_name in ['null', '']):
             raise ARMException('No database name defined')
         if (db_name not in list(
                 map(lambda db: db['database'], self.show_databases()))):
             raise ObjectNotFound(db_name + " does not exist")
         self.db_proxy.deleteDatabase(db_name, self.session_id)
         return 'Database successfully deleted'
     except ObjectNotFound as ex:
         self.close()
         raise ObjectNotFoundHTTPError('The provided asset name')
     except DatabaseProxyException as ex:
         raise ARMHTTPError(ex)
     except ARMException as ex:
         raise ARMHTTPError(ex)
Esempio n. 2
0
  def get_requirement_by_shortcode(self, shortcode):
    found_requirement = None
    requirements = self.get_requirements().values()
    idx = 0

    while found_requirement is None and idx < len(requirements):
      requirement = requirements[idx]
      if requirement.theLabel == shortcode:
        found_requirement = requirement
      idx +=1

    if found_requirement is None:
      self.close()
      raise ObjectNotFoundHTTPError(obj='The provided requirement shortcode')

    return found_requirement
Esempio n. 3
0
    def update_goal(self, goal, name):
        params = GoalParameters(goalName=goal.theName,
                                goalOrig=goal.theOriginator,
                                tags=goal.theTags,
                                properties=goal.theEnvironmentProperties)

        try:
            goalId = self.db_proxy.getDimensionId(name, 'goal')
            params.setId(goalId)
            self.db_proxy.updateGoal(params)
        except ObjectNotFound as ex:
            self.close()
            raise ObjectNotFoundHTTPError(ex)
        except DatabaseProxyException as ex:
            self.close()
            raise ARMHTTPError(ex)
Esempio n. 4
0
  def get_goal_by_name(self, name, coloured=False, simplify=True):
    found_goal = None
    goalId = self.db_proxy.getDimensionId(name,'goal')
    goals = self.get_goals(goalId,coloured=coloured, simplify=False)

    if goals is not None:
      found_goal = goals.get(name)

    if found_goal is None:
      self.close()
      raise ObjectNotFoundHTTPError('The provided goal name')

    if simplify:
      found_goal = self.simplify(found_goal)

    return found_goal
Esempio n. 5
0
    def get_obstacle_by_name(self, name, simplify=True):
        obsId = self.db_proxy.getDimensionId(name, 'obstacle')
        found_obstacle = None
        obstacles = self.get_obstacles(obsId, simplify=False)

        if obstacles is not None:
            found_obstacle = obstacles.get(name)

        if found_obstacle is None:
            self.close()
            raise ObjectNotFoundHTTPError('The provided obstacle name')

        if simplify:
            found_obstacle = self.simplify(found_obstacle)

        return found_obstacle
Esempio n. 6
0
 def delete_object_by_4parameters(self, environment, depender, dependee,
                                  dependency):
     try:
         dep = self.db_proxy.getDependency(environment, depender, dependee,
                                           dependency)
         self.db_proxy.deleteDependency(dep.theId, dep.theDependencyType)
         return 1
     except ObjectNotFound as ex:
         self.close()
         raise ObjectNotFoundHTTPError('The provided dependency name')
     except DatabaseProxyException as ex:
         self.close()
         raise ARMHTTPError(ex)
     except ARMException as ex:
         self.close()
         raise ARMHTTPError(ex)
Esempio n. 7
0
 def get_misusability_model(self, mc_name,tc_name, pathValues = []):
   fontName, fontSize, apFontName = get_fonts(session_id=self.session_id)
   if tc_name == 'all':
     tc_name = ''
   try:
     associations = self.db_proxy.assumptionTaskModel(mc_name,tc_name)
     model = GraphicalAssumptionTaskModel(associations,db_proxy=self.db_proxy, font_name=fontName, font_size=fontSize)
     dot_code = model.graph()
     if not dot_code:
       raise ObjectNotFoundHTTPError('The misusability model')
     return dot_code
   except DatabaseProxyException as ex:
     self.close()
     raise ARMHTTPError(ex)
   except ARMException as ex:
     self.close()
     raise ARMHTTPError(ex)
Esempio n. 8
0
 def generate_asset_from_template(self, cmName, taName):
     try:
         cm = self.db_proxy.dimensionObject(cmName, 'countermeasure')
         taParameters = cairis.core.AssetParametersFactory.buildFromTemplate(
             taName, cm.environments())
         self.db_proxy.nameCheck(taParameters.name(), 'asset')
         assetId = self.db_proxy.addAsset(taParameters)
         self.db_proxy.addTrace('countermeasure_asset', cm.id(), assetId)
     except ObjectNotFound as ex:
         self.close()
         raise ObjectNotFoundHTTPError('The provided countermeasure name')
     except DatabaseProxyException as ex:
         self.close()
         raise ARMHTTPError(ex)
     except ARMException as ex:
         self.close()
         raise ARMHTTPError(ex)
Esempio n. 9
0
 def get_risk_rating_by_tve(self, threat_name, vulnerability_name, environment_name):
   """
   :rtype: RiskRating
   """
   try:
     rating = self.db_proxy.riskRating(threat_name, vulnerability_name, environment_name)
     risk_rating = RiskRating(threat_name, vulnerability_name, environment_name, rating)
     return risk_rating
   except DatabaseProxyException as ex:
     self.close()
     raise ARMHTTPError(ex)
   except ARMException as ex:
     self.close()
     raise ARMHTTPError(ex)
   except TypeError:
     self.close()
     raise ObjectNotFoundHTTPError(obj='A rating for the risk')
Esempio n. 10
0
    def get_object_by_name(self, name, simplify=True):
        try:
            personaId = self.db_proxy.getDimensionId(name, 'persona')
            personas = self.db_proxy.getPersonas(personaId)
        except DatabaseProxyException as ex:
            self.close()
            raise ARMHTTPError(ex)
        except ARMException as ex:
            self.close()
            raise ARMHTTPError(ex)
        found_persona = personas.get(name, None)

        if found_persona is None:
            self.close()
            raise ObjectNotFoundHTTPError('The provided persona name')

        found_persona = self.simplify(found_persona)
        return found_persona
Esempio n. 11
0
 def get_risk_analysis_model(self, environment_name, dim_name, obj_name,model_layout):
   fontName, fontSize, apFontName = get_fonts(session_id=self.session_id)
   try:
     riskAnalysisModel = self.db_proxy.riskAnalysisModel(environment_name, dim_name, obj_name)
     tLinks = EnvironmentModel(riskAnalysisModel, environment_name, self.db_proxy, model_layout, fontName=fontName, fontSize=fontSize)
     dot_code = tLinks.graph()
     if not dot_code:
       raise ObjectNotFoundHTTPError('The risk analysis model')
     return dot_code
   except DatabaseProxyException as ex:
     self.close()
     raise ARMHTTPError(ex)
   except ARMException as ex:
     self.close()
     raise ARMHTTPError(ex)
   except Exception as ex:
     self.close()
     print(ex)
Esempio n. 12
0
    def get_role_by_id(self, role_id, simplify=True):
        found_role = None
        roles = self.db_proxy.getRoles()
        idx = 0

        while found_role is None and idx < len(roles):
            if list(roles.values())[idx].theId == role_id:
                found_role = list(roles.values())[idx]
            idx += 1

        if found_role is None:
            self.close()
            raise ObjectNotFoundHTTPError('The provided role name')

        if simplify:
            found_role = self.simplify(found_role)

        return found_role
Esempio n. 13
0
 def generate_asset(self, cmName, pathValues=[]):
     try:
         cm = self.db_proxy.dimensionObject(cmName, 'countermeasure')
         assetParameters = cairis.core.AssetParametersFactory.build(
             cm, self.db_proxy)
         self.db_proxy.nameCheck(assetParameters.name(), 'asset')
         assetId = self.db_proxy.addAsset(assetParameters)
         self.db_proxy.addTrace('countermeasure_asset', cm.id(), assetId)
         return 'Asset ' + cmName + ' CM created'
     except ObjectNotFound as ex:
         self.close()
         raise ObjectNotFoundHTTPError('The provided countermeasure name')
     except DatabaseProxyException as ex:
         self.close()
         raise ARMHTTPError(ex)
     except ARMException as ex:
         self.close()
         raise ARMHTTPError(ex)
Esempio n. 14
0
  def get_object_by_name(self, name, simplify=True):
    try:
      taskId = self.db_proxy.getDimensionId(name,'task')
      tasks = self.db_proxy.getTasks(taskId)
    except DatabaseProxyException as ex:
      self.close()
      raise ARMHTTPError(ex)
    except ARMException as ex:
      self.close()
      raise ARMHTTPError(ex)

    found_task = tasks.get(name, None)

    if found_task is None:
      self.close()
      raise ObjectNotFoundHTTPError('The provided task name')
    found_task = self.simplify(found_task)
    return found_task
Esempio n. 15
0
 def situate_countermeasure_pattern(self,cmName,spName):
   try:
     cm = self.db_proxy.dimensionObject(cmName,'countermeasure')
     patternId = self.db_proxy.getDimensionId(spName,'securitypattern')
     assetParametersList = []
     for assetName in self.db_proxy.patternAssets(patternId):
       assetParametersList.append(cairis.core.AssetParametersFactory.buildFromTemplate(assetName,cm.environments()))
     self.db_proxy.addSituatedAssets(patternId,assetParametersList)
     self.db_proxy.addTrace('countermeasure_securitypattern',cm.id(),patternId)
   except ObjectNotFound as ex:
     self.close()
     raise ObjectNotFoundHTTPError('The provided countermeasure name')
   except DatabaseProxyException as ex:
     self.close()
     raise ARMHTTPError(ex)
   except ARMException as ex:
     self.close()
     raise ARMHTTPError(ex)
Esempio n. 16
0
    def get_threat_by_name(self, name, simplify=True):
        found_threat = None
        try:
            threats = self.db_proxy.getThreats()
        except DatabaseProxyException as ex:
            self.close()
            raise ARMHTTPError(ex)

        if threats is not None:
            found_threat = threats.get(name)

        if found_threat is None:
            self.close()
            raise ObjectNotFoundHTTPError('The provided threat name')

        if simplify:
            found_threat = self.simplify(found_threat)

        return found_threat
Esempio n. 17
0
 def get_persona_model(self, persona_name, variable_name,
                       characteristic_name):
     fontName, fontSize, apFontName = get_fonts(session_id=self.session_id)
     try:
         modelAssocs = self.db_proxy.assumptionPersonaModel(
             persona_name, variable_name, characteristic_name)
         associations = AssumptionPersonaModel(modelAssocs,
                                               font_name=fontName,
                                               font_size=fontSize)
         dot_code = associations.graph()
         if not dot_code:
             raise ObjectNotFoundHTTPError('The persona model')
         return dot_code
     except DatabaseProxyException as ex:
         self.close()
         raise ARMHTTPError(ex)
     except ARMException as ex:
         self.close()
         raise ARMHTTPError(ex)
Esempio n. 18
0
    def get_vulnerability_by_name(self, name, simplify=True):
        found_vulnerability = None
        try:
            vulnerabilities = self.db_proxy.getVulnerabilities()
        except DatabaseProxyException as ex:
            self.close()
            raise ARMHTTPError(ex)

        if vulnerabilities is not None:
            found_vulnerability = vulnerabilities.get(name)

        if found_vulnerability is None:
            self.close()
            raise ObjectNotFoundHTTPError('The provided vulnerability name')

        if simplify:
            found_vulnerability = self.simplify(found_vulnerability)

        return found_vulnerability
Esempio n. 19
0
  def delete_environment(self, name=None, env_id=None):
    if name is not None:
      found_environment = self.get_environment_by_name(name, simplify=False)
      if found_environment is None:
        raise ObjectNotFoundHTTPError('The provided environment name')
      env_id = found_environment.theId

    if env_id is not None and env_id > -1:
      try:
        self.db_proxy.deleteEnvironment(env_id)
      except DatabaseProxyException as ex:
        self.close()
        raise ARMHTTPError(ex)
      except ARMException as ex:
        self.close()
        raise ARMHTTPError(ex)
    else:
      self.close()
      raise MissingParameterHTTPError(param_names=['id'])
Esempio n. 20
0
 def update_object(self, response, resp_name):
     params = ResponseParameters(respName=response.theName,
                                 respRisk=response.theRisk,
                                 tags=response.theTags,
                                 cProps=response.theEnvironmentProperties,
                                 rType=response.theResponseType)
     try:
         respId = self.db_proxy.getDimensionId(resp_name, 'response')
         params.setId(respId)
         self.db_proxy.updateResponse(params)
     except ObjectNotFound as ex:
         self.close()
         raise ObjectNotFoundHTTPError('The provided response name')
     except DatabaseProxyException as ex:
         self.close()
         raise ARMHTTPError(ex)
     except ARMException as ex:
         self.close()
         raise ARMHTTPError(ex)
Esempio n. 21
0
    def update_task_characteristic(self, tc, name):
        tcParams = TaskCharacteristicParameters(pName=tc.theTaskName,
                                                modQual=tc.theModQual,
                                                cDesc=tc.theName,
                                                pcGrounds=tc.theGrounds,
                                                pcWarrant=tc.theWarrant,
                                                pcBacking=[],
                                                pcRebuttal=tc.theRebuttal)

        try:
            tcId = self.db_proxy.getDimensionId(name, 'task_characteristic')
            tcParams.setId(tcId)
            self.db_proxy.updateTaskCharacteristic(tcParams)
        except ObjectNotFound as ex:
            self.close()
            raise ObjectNotFoundHTTPError('The provided task characteristic')
        except ARMException as ex:
            self.close()
            raise ARMHTTPError(ex)
Esempio n. 22
0
  def get_requirement_by_id(self, req_id):
    found_requirement = None
    try:
      requirements = self.db_proxy.getRequirements()
    except DatabaseProxyException as ex:
      self.close()
      raise ARMHTTPError(ex)

    idx = 0
    while found_requirement is None and idx < len(requirements):
      if requirements.values()[idx].theId == int(req_id):
        found_requirement = requirements.values()[idx]
      idx += 1

    if found_requirement is None:
      self.close()
      raise ObjectNotFoundHTTPError('The provided requirement ID')

    return found_requirement
Esempio n. 23
0
  def get_environment_by_name(self, name, simplify=True):
    found_environment = None
    try:
      environments = self.db_proxy.getEnvironments()
    except DatabaseProxyException as ex:
      self.close()
      raise ARMHTTPError(ex)

    if environments is not None:
      found_environment = environments.get(name)

    if found_environment is None:
      self.close()
      raise ObjectNotFoundHTTPError('The provided environment name')

    if simplify:
      found_environment = self.simplify(found_environment)

    return found_environment
Esempio n. 24
0
    def get(self, ap_name):
        session_id = get_session_id(session, request)
        model_generator = get_model_generator()

        dao = ArchitecturalPatternDAO(session_id)
        dot_code = dao.get_component_model(ap_name)
        dao.close()

        if not isinstance(dot_code, str):
            raise ObjectNotFoundHTTPError('The model')

        resp = make_response(
            model_generator.generate(dot_code, renderer='dot'), httplib.OK)
        accept_header = request.headers.get('Accept', 'image/svg+xml')
        if accept_header.find('text/plain') > -1:
            resp.headers['Content-type'] = 'text/plain'
        else:
            resp.headers['Content-type'] = 'image/svg+xml'

        return resp
Esempio n. 25
0
 def get_task_model(self, environment_name,task_name,misusecase_name):
   fontName, fontSize, apFontName = get_fonts(session_id=self.session_id)
   try:
     mcFilter = False
     filter_name = task_name
     if misusecase_name != '': 
       mcFilter = True
       filter_name = misusecase_name
     associationDirectory = self.db_proxy.taskModel(environment_name,filter_name,mcFilter)
     associations = KaosModel(associationDirectory.values(), environment_name, kaosModelType = 'task',goalName = filter_name,db_proxy=self.db_proxy, font_name=fontName, font_size=fontSize)
     dot_code = associations.graph()
     if not dot_code:
       raise ObjectNotFoundHTTPError('The task model')
     return dot_code
   except DatabaseProxyException as ex:
     self.close()
     raise ARMHTTPError(ex)
   except ARMException as ex:
     self.close()
     raise ARMHTTPError(ex)
Esempio n. 26
0
  def get_requirement_by_name(self, name):
    found_requirement = None
    try:
      requirements = self.db_proxy.getRequirements()
    except DatabaseProxyException as ex:
      self.close()
      raise ARMHTTPError(ex)

    if requirements is not None:
      idx = 0
      while found_requirement is None and idx < len(requirements):
        if (requirements.values()[idx].theName == name) or (requirements.values()[idx].theLabel == name):
          found_requirement = requirements.values()[idx]
        idx += 1

    if found_requirement is None:
      self.close()
      raise ObjectNotFoundHTTPError('The provided requirement name ' + '"' + name + '"')

    return found_requirement
Esempio n. 27
0
 def get_dataflow_diagram(self, environment_name, filter_element):
     fontName, fontSize, apFontName = get_fonts(session_id=self.session_id)
     try:
         dfdRows = self.db_proxy.dataFlowDiagram(environment_name,
                                                 filter_element)
         associations = DataFlowDiagram(dfdRows,
                                        environment_name,
                                        self.db_proxy,
                                        font_name=fontName,
                                        font_size=fontSize)
         dot_code = associations.graph()
         if not dot_code:
             raise ObjectNotFoundHTTPError('The data flow diagram')
         return dot_code
     except DatabaseProxyException as ex:
         self.close()
         raise ARMHTTPError(ex)
     except ARMException as ex:
         self.close()
         raise ARMHTTPError(ex)
Esempio n. 28
0
  def get_asset_by_name(self, name, simplify=True):
    try:
      assetId = self.db_proxy.getDimensionId(name,'asset')
      assets = self.db_proxy.getAssets(assetId)
    except DatabaseProxyException as ex:
      self.close()
      raise ARMHTTPError(ex)
    except ARMException as ex:
      self.close()
      raise ARMHTTPError(ex)

    if assets is not None:
      found_asset = assets.get(name)

    if found_asset is None:
      self.close()
      raise ObjectNotFoundHTTPError('The provided asset name')

    if simplify:
      found_asset = self.simplify(found_asset)
    return found_asset
Esempio n. 29
0
    def delete_asset(self, name=None, asset_id=-1):
        if name is not None:
            found_asset = self.get_asset_by_name(name)
        elif asset_id > -1:
            found_asset = self.get_asset_by_id(asset_id)
        else:
            self.close()
            raise MissingParameterHTTPError(param_names=['name'])

        if found_asset is None or not isinstance(found_asset, Asset):
            self.close()
            raise ObjectNotFoundHTTPError('The provided asset name')

        try:
            self.db_proxy.deleteAsset(found_asset.theId)
        except DatabaseProxyException as ex:
            self.close()
            raise ARMHTTPError(ex)
        except ARMException as ex:
            self.close()
            raise ARMHTTPError(ex)
Esempio n. 30
0
    def delete_role(self, name=None, role_id=-1):
        if name is not None:
            found_role = self.get_role_by_name(name)
        elif role_id > -1:
            found_role = self.get_role_by_id(role_id)
        else:
            self.close()
            raise MissingParameterHTTPError(param_names=['name'])

        if found_role is None or not isinstance(found_role, Role):
            self.close()
            raise ObjectNotFoundHTTPError('The provided role name')

        try:
            self.db_proxy.deleteRole(found_role.theId)
        except DatabaseProxyException as ex:
            self.close()
            raise ARMHTTPError(ex)
        except ARMException as ex:
            self.close()
            raise ARMHTTPError(ex)