Exemplo n.º 1
0
 def setUp(self):
   call([os.environ['CAIRIS_SRC'] + "/test/initdb.sh"])
   cairis.core.BorgFactory.initialise()
   f = open(os.environ['CAIRIS_SRC'] + '/test/vulnerabilities.json')
   d = json.load(f)
   f.close()
   b = Borg()
   self.iVtypes = d['valuetypes']
   self.ivt1 = ValueTypeParameters(self.iVtypes[0]["theName"], self.iVtypes[0]["theDescription"], self.iVtypes[0]["theValueType"])
   self.ivt2 = ValueTypeParameters(self.iVtypes[1]["theName"], self.iVtypes[1]["theDescription"], self.iVtypes[1]["theValueType"])
   b.dbProxy.addValueType(self.ivt1)
   b.dbProxy.addValueType(self.ivt2)
   self.oVtypes = b.dbProxy.getValueTypes('vulnerability_type')
   ienvs = d['environments']
   self.iep1 = EnvironmentParameters(ienvs[0]["theName"],ienvs[0]["theShortCode"],ienvs[0]["theDescription"])
   self.iep2 = EnvironmentParameters(ienvs[1]["theName"],ienvs[1]["theShortCode"],ienvs[1]["theDescription"])
   self.iep3 = EnvironmentParameters(ienvs[2]["theName"],ienvs[2]["theShortCode"],ienvs[2]["theDescription"])
   b.dbProxy.addEnvironment(self.iep1)
   b.dbProxy.addEnvironment(self.iep2)
   b.dbProxy.addEnvironment(self.iep3)
   self.oenvs = b.dbProxy.getEnvironments()
   self.iassets = d['assets']
   self.iaeps = [AssetEnvironmentProperties(self.iassets[0]["theEnvironmentProperties"][0][0],self.iassets[0]["theEnvironmentProperties"][0][1],self.iassets[0]["theEnvironmentProperties"][0][2])]
   self.iap = AssetParameters(self.iassets[0]["theName"],self.iassets[0]["theShortCode"],self.iassets[0]["theDescription"],self.iassets[0]["theSignificance"],self.iassets[0]["theType"],"0","N/A",[],[],self.iaeps)
   b.dbProxy.addAsset(self.iap)
   self.oaps = b.dbProxy.getAssets()
   self.iVuln = d['vulnerabilities']
Exemplo n.º 2
0
 def setUp(self):
     call([os.environ['CAIRIS_CFG_DIR'] + "/initdb.sh"])
     cairis.core.BorgFactory.initialise()
     f = open(os.environ['CAIRIS_SRC'] + '/test/goals.json')
     d = json.load(f)
     f.close()
     ienvs = d['environments']
     iep1 = EnvironmentParameters(ienvs[0]["theName"],
                                  ienvs[0]["theShortCode"],
                                  ienvs[0]["theDescription"])
     iep2 = EnvironmentParameters(ienvs[1]["theName"],
                                  ienvs[1]["theShortCode"],
                                  ienvs[1]["theDescription"])
     b = Borg()
     b.dbProxy.addEnvironment(iep1)
     b.dbProxy.addEnvironment(iep2)
     iassets = d['assets']
     iaeps1 = AssetEnvironmentProperties(
         iassets[0]["theEnvironmentProperties"][0][0],
         iassets[0]["theEnvironmentProperties"][0][1],
         iassets[0]["theEnvironmentProperties"][0][2])
     iaeps2 = AssetEnvironmentProperties(
         iassets[0]["theEnvironmentProperties"][1][0],
         iassets[0]["theEnvironmentProperties"][1][1],
         iassets[0]["theEnvironmentProperties"][1][2])
     iap1 = AssetParameters(iassets[0]["theName"],
                            iassets[0]["theShortCode"],
                            iassets[0]["theDescription"],
                            iassets[0]["theSignificance"],
                            iassets[0]["theType"], "0", "N/A", [], [],
                            [iaeps1, iaeps2])
     b.dbProxy.addAsset(iap1)
     self.iGoals = d['goals']
Exemplo n.º 3
0
    def testStandardEnvironment(self):
        iep1 = EnvironmentParameters(self.ienvs[0]["theName"],
                                     self.ienvs[0]["theShortCode"],
                                     self.ienvs[0]["theDescription"])
        iep2 = EnvironmentParameters(self.ienvs[1]["theName"],
                                     self.ienvs[1]["theShortCode"],
                                     self.ienvs[1]["theDescription"])
        iep3 = EnvironmentParameters(self.ienvs[2]["theName"],
                                     self.ienvs[2]["theShortCode"],
                                     self.ienvs[2]["theDescription"])
        b = Borg()
        b.dbProxy.addEnvironment(iep1)
        b.dbProxy.addEnvironment(iep2)
        b.dbProxy.addEnvironment(iep3)
        oenvs = b.dbProxy.getEnvironments()
        oep1 = oenvs[self.ienvs[0]["theName"]]
        self.assertEqual(iep1.name(), oep1.name())
        self.assertEqual(iep1.shortCode(), oep1.shortCode())
        self.assertEqual(iep1.description(), oep1.description())
        oep2 = oenvs[self.ienvs[1]["theName"]]
        self.assertEqual(iep2.name(), oep2.name())
        self.assertEqual(iep2.shortCode(), oep2.shortCode())
        self.assertEqual(iep2.description(), oep2.description())
        oep3 = oenvs[self.ienvs[2]["theName"]]
        self.assertEqual(iep3.name(), oep3.name())
        self.assertEqual(iep3.shortCode(), oep3.shortCode())
        self.assertEqual(iep3.description(), oep3.description())

        b.dbProxy.deleteEnvironment(oep1.id())
        b.dbProxy.deleteEnvironment(oep2.id())
        b.dbProxy.deleteEnvironment(oep3.id())
Exemplo n.º 4
0
    def testStandardEnvironment(self):
        iep1 = EnvironmentParameters(self.ienvs[0]["theName"],
                                     self.ienvs[0]["theShortCode"],
                                     self.ienvs[0]["theDescription"])
        iep2 = EnvironmentParameters(self.ienvs[1]["theName"],
                                     self.ienvs[1]["theShortCode"],
                                     self.ienvs[1]["theDescription"])
        iep3 = EnvironmentParameters(self.ienvs[2]["theName"],
                                     self.ienvs[2]["theShortCode"],
                                     self.ienvs[2]["theDescription"])
        b = Borg()
        iep1.theShortCode = '0' * 25
        with self.assertRaises(AttributeTooBig):
            b.dbProxy.addEnvironment(iep1)
        iep1.theShortCode = self.ienvs[0]["theShortCode"]
        b.dbProxy.addEnvironment(iep1)
        b.dbProxy.addEnvironment(iep2)
        b.dbProxy.addEnvironment(iep3)
        oenvs = b.dbProxy.getEnvironments()
        oep1 = oenvs[self.ienvs[0]["theName"]]
        self.assertEqual(iep1.name(), oep1.name())
        self.assertEqual(iep1.shortCode(), oep1.shortCode())
        self.assertEqual(iep1.description(), oep1.description())
        oep2 = oenvs[self.ienvs[1]["theName"]]
        self.assertEqual(iep2.name(), oep2.name())
        self.assertEqual(iep2.shortCode(), oep2.shortCode())
        self.assertEqual(iep2.description(), oep2.description())
        oep3 = oenvs[self.ienvs[2]["theName"]]
        self.assertEqual(iep3.name(), oep3.name())
        self.assertEqual(iep3.shortCode(), oep3.shortCode())
        self.assertEqual(iep3.description(), oep3.description())

        iep4 = EnvironmentParameters(
            self.ienvs[3]["Composite_name"], 'COMP', 'Composite test',
            [iep1.name(), iep2.name(), iep3.name()],
            self.ienvs[4]["Duplication"])
        b.dbProxy.addEnvironment(iep4)

        oenvs = b.dbProxy.getEnvironments()
        oep4 = oenvs[self.ienvs[3]["Composite_name"]]
        self.assertEqual(iep4.name(), oep4.name())
        self.assertEqual(iep4.shortCode(), oep4.shortCode())
        self.assertEqual(iep4.description(), oep4.description())
        self.assertEqual(iep4.environments(), oep4.environments())
        self.assertEqual(iep4.duplicateProperty(), oep4.duplicateProperty())

        oep1 = oenvs[self.ienvs[0]["theName"]]
        oep2 = oenvs[self.ienvs[1]["theName"]]
        oep3 = oenvs[self.ienvs[2]["theName"]]

        self.assertRaises(DatabaseProxyException, b.dbProxy.deleteEnvironment,
                          oep1.id())
        b.dbProxy.deleteEnvironment(oep4.id())
        b.dbProxy.deleteEnvironment(oep1.id())
        b.dbProxy.deleteEnvironment(oep2.id())
        b.dbProxy.deleteEnvironment(oep3.id())
Exemplo n.º 5
0
    def setUp(self):
        call([os.environ['CAIRIS_SRC'] + "/test/initdb.sh"])
        cairis.core.BorgFactory.initialise()
        f = open(os.environ['CAIRIS_SRC'] + '/test/personas.json')
        d = json.load(f)
        f.close()
        self.iEnvironments = d['environments']
        iep1 = EnvironmentParameters(self.iEnvironments[0]["theName"],
                                     self.iEnvironments[0]["theShortCode"],
                                     self.iEnvironments[0]["theDescription"])
        b = Borg()
        b.dbProxy.addEnvironment(iep1)
        self.theEnvironments = b.dbProxy.getEnvironments()

        self.iRoles = d['roles']
        irp = RoleParameters(self.iRoles[0]["theName"],
                             self.iRoles[0]["theType"],
                             self.iRoles[0]["theShortCode"],
                             self.iRoles[0]["theDescription"], [])
        b.dbProxy.addRole(irp)
        self.theRoles = b.dbProxy.getRoles()
        self.iPersonas = d['personas']
        self.iExternalDocuments = d['external_documents']
        self.iDocumentReferences = d['document_references']
        self.iPersonaCharacteristics = d['persona_characteristics']
Exemplo n.º 6
0
 def setUp(self):
   call([os.environ['CAIRIS_SRC'] + "/test/initdb.sh"])
   cairis.core.BorgFactory.initialise()
   f = open(os.environ['CAIRIS_SRC'] + '/test/assets.json')
   d = json.load(f)
   f.close()
   ienvs = d['environments']
   self.iep1 = EnvironmentParameters(ienvs[0]["theName"],ienvs[0]["theShortCode"],ienvs[0]["theDescription"])
   self.iep2 = EnvironmentParameters(ienvs[1]["theName"],ienvs[1]["theShortCode"],ienvs[1]["theDescription"])
   self.iep3 = EnvironmentParameters(ienvs[2]["theName"],ienvs[2]["theShortCode"],ienvs[2]["theDescription"])
   b = Borg()
   b.dbProxy.addEnvironment(self.iep1)
   b.dbProxy.addEnvironment(self.iep2)
   b.dbProxy.addEnvironment(self.iep3)
   self.oenvs = b.dbProxy.getEnvironments()
   self.iassets = d['assets']
Exemplo n.º 7
0
  def setUp(self):
    call([os.environ['CAIRIS_SRC'] + "/test/initdb.sh"])
    cairis.core.BorgFactory.initialise()
    f = open(os.environ['CAIRIS_SRC'] + '/test/locations.json')
    d = json.load(f)
    f.close()
    self.iEnvironments = d['environments']
    iep1 = EnvironmentParameters(self.iEnvironments[0]["theName"],self.iEnvironments[0]["theShortCode"],self.iEnvironments[0]["theDescription"])
    b = Borg()
    b.dbProxy.addEnvironment(iep1)
    self.theEnvironments = b.dbProxy.getEnvironments()

    self.iRoles = d['roles']
    irp = RoleParameters(self.iRoles[0]["theName"], self.iRoles[0]["theType"], self.iRoles[0]["theShortCode"], self.iRoles[0]["theDescription"],[])
    b.dbProxy.addRole(irp)
    self.theRoles = b.dbProxy.getRoles()
    self.iPersonas = d['personas']
    ipp = PersonaParameters(self.iPersonas[0]["theName"],self.iPersonas[0]["theActivities"],self.iPersonas[0]["theAttitudes"],self.iPersonas[0]["theAptitudes"],self.iPersonas[0]["theMotivations"],self.iPersonas[0]["theSkills"],self.iPersonas[0]["theIntrinsic"],self.iPersonas[0]["theContextual"],"","0",self.iPersonas[0]["thePersonaType"],[],[PersonaEnvironmentProperties(self.iPersonas[0]["theEnvironmentProperties"][0]["theName"],(self.iPersonas[0]["theEnvironmentProperties"][0]["theDirectFlag"] == "True"),self.iPersonas[0]["theEnvironmentProperties"][0]["theNarrative"],self.iPersonas[0]["theEnvironmentProperties"][0]["theRole"])],[])
    b.dbProxy.addPersona(ipp) 
    thePersonas = b.dbProxy.getPersonas()
    self.thePersona = thePersonas[self.iPersonas[0]["theName"]]

    self.iassets = d['assets']
    iaeps = [AssetEnvironmentProperties(self.iassets[0]["theEnvironmentProperties"][0][0],self.iassets[0]["theEnvironmentProperties"][0][1],self.iassets[0]["theEnvironmentProperties"][0][2])]
    iap = AssetParameters(self.iassets[0]["theName"],self.iassets[0]["theShortCode"],self.iassets[0]["theDescription"],self.iassets[0]["theSignificance"],self.iassets[0]["theType"],"0","N/A",[],[],iaeps)
    b = Borg()
    b.dbProxy.addAsset(iap)

    oaps = b.dbProxy.getAssets()
    self.theAsset = oaps[self.iassets[0]["theName"]]
    self.ilocations = d['locations']
Exemplo n.º 8
0
 def parameters(self):
     parameters = EnvironmentParameters(
         self.environmentName, self.environmentShortCode,
         self.environmentDescription, self.theEnvironments,
         self.theDuplicateProperty, self.theOverridingEnvironment,
         self.theTensions)
     parameters.setId(self.theEnvironmentId)
     return parameters
Exemplo n.º 9
0
 def to_environment_parameters(self, environment):
     assert isinstance(environment, Environment)
     env_params = EnvironmentParameters(
         conName=environment.theName,
         conSc=environment.theShortCode,
         conDesc=environment.theDescription,
         environments=environment.theEnvironments,
         duplProperty=environment.theDuplicateProperty,
         overridingEnvironment=environment.theOverridingEnvironment,
         envTensions=environment.theTensions)
     return env_params
Exemplo n.º 10
0
 def setUp(self):
     call([os.environ['CAIRIS_CFG_DIR'] + "/initdb.sh"])
     cairis.core.BorgFactory.initialise()
     f = open(os.environ['CAIRIS_SRC'] + '/test/attackers.json')
     d = json.load(f)
     f.close()
     ienvs = d['environments']
     iep = EnvironmentParameters(ienvs[0]["theName"],
                                 ienvs[0]["theShortCode"],
                                 ienvs[0]["theDescription"])
     iep1 = EnvironmentParameters(ienvs[1]["theName"],
                                  ienvs[1]["theShortCode"],
                                  ienvs[1]["theDescription"])
     b = Borg()
     b.dbProxy.addEnvironment(iep)
     b.dbProxy.addEnvironment(iep1)
     iRoles = d['roles']
     irp = RoleParameters(iRoles[0]["theName"], iRoles[0]["theType"],
                          iRoles[0]["theShortCode"],
                          iRoles[0]["theDescription"], [])
     b.dbProxy.addRole(irp)
     self.iAttackers = d['attackers']
Exemplo n.º 11
0
    def setUpClass(cls):
        call([os.environ['CAIRIS_CFG_DIR'] + "/initdb.sh"])
        cairis.core.BorgFactory.initialise()

        f = open(os.environ['CAIRIS_SRC'] + '/test/dataflow.json')
        d = json.load(f)
        f.close()
        iEnvironments = d['environments']
        iep1 = EnvironmentParameters(iEnvironments[0]["theName"],
                                     iEnvironments[0]["theShortCode"],
                                     iEnvironments[0]["theDescription"])
        b = Borg()
        b.dbProxy.addEnvironment(iep1)

        iRoles = d['roles']
        irp = RoleParameters(iRoles[0]["theName"], iRoles[0]["theType"],
                             iRoles[0]["theShortCode"],
                             iRoles[0]["theDescription"], [])
        b.dbProxy.addRole(irp)

        iUseCases = d['use_cases']
        ucName = iUseCases[0]["theName"]
        ucAuthor = iUseCases[0]["theAuthor"]
        ucCode = iUseCases[0]["theCode"]
        ucDesc = iUseCases[0]["theDescription"]
        ucActor = iUseCases[0]["theActor"]
        ucEnv = iUseCases[0]["theEnvironments"][0]
        ucEnvName = ucEnv["theName"]
        ucPre = ucEnv["thePreconditions"]
        ucPost = ucEnv["thePostconditions"]
        ss = Steps()
        for ucStep in ucEnv["theFlow"]:
            ss.append(Step(ucStep["theDescription"]))
        ucep = UseCaseEnvironmentProperties(ucEnvName, ucPre, ss, ucPost)
        iuc = UseCaseParameters(ucName, ucAuthor, ucCode, [ucActor], ucDesc,
                                [], [ucep])
        b = Borg()
        b.dbProxy.addUseCase(iuc)

        for iAsset in d['assets']:
            iaeps = [
                AssetEnvironmentProperties(
                    iAsset["theEnvironmentProperties"][0][0],
                    iAsset["theEnvironmentProperties"][0][1],
                    iAsset["theEnvironmentProperties"][0][2])
            ]
            iap = AssetParameters(iAsset["theName"], iAsset["theShortCode"],
                                  iAsset["theDescription"],
                                  iAsset["theSignificance"], iAsset["theType"],
                                  "0", "N/A", [], [], iaeps)
            b.dbProxy.addAsset(iap)
Exemplo n.º 12
0
 def setUp(self):
   call([os.environ['CAIRIS_SRC'] + "/test/initdb.sh"])
   cairis.core.BorgFactory.initialise()
   f = open(os.environ['CAIRIS_SRC'] + '/test/threats.json')
   d = json.load(f)
   f.close()
   self.ienvs = d['environments']
   self.iep = EnvironmentParameters(self.ienvs[0]["theName"],self.ienvs[0]["theShortCode"],self.ienvs[0]["theDescription"])
   b = Borg()
   b.dbProxy.addEnvironment(self.iep)
   self.oenvs = b.dbProxy.getEnvironments()
   self.iRoles = d['roles']
   self.irp = RoleParameters(self.iRoles[0]["theName"], self.iRoles[0]["theType"], self.iRoles[0]["theShortCode"], self.iRoles[0]["theDescription"],[])
   b.dbProxy.addRole(self.irp)
   self.oRoles = b.dbProxy.getRoles()
   self.iPersonas = d['personas']
   self.ipp = PersonaParameters(self.iPersonas[0]["theName"],self.iPersonas[0]["theActivities"],self.iPersonas[0]["theAttitudes"],self.iPersonas[0]["theAptitudes"],self.iPersonas[0]["theMotivations"],self.iPersonas[0]["theSkills"],self.iPersonas[0]["theIntrinsic"],self.iPersonas[0]["theContextual"],"","0",self.iPersonas[0]["thePersonaType"],[],[PersonaEnvironmentProperties(self.iPersonas[0]["theEnvironmentProperties"][0]["theName"],(self.iPersonas[0]["theEnvironmentProperties"][0]["theDirectFlag"] == "True"),self.iPersonas[0]["theEnvironmentProperties"][0]["theNarrative"],self.iPersonas[0]["theEnvironmentProperties"][0]["theRole"])],[])
   b.dbProxy.addPersona(self.ipp)
   self.opp = b.dbProxy.getPersonas()
   self.iExternalDocuments = d['external_documents']
   self.iec1 = ExternalDocumentParameters(self.iExternalDocuments[0]["theName"],self.iExternalDocuments[0]["theVersion"],self.iExternalDocuments[0]["thePublicationDate"],self.iExternalDocuments[0]["theAuthors"],self.iExternalDocuments[0]["theDescription"])
   self.iec2 = ExternalDocumentParameters(self.iExternalDocuments[1]["theName"],self.iExternalDocuments[1]["theVersion"],self.iExternalDocuments[1]["thePublicationDate"],self.iExternalDocuments[1]["theAuthors"],self.iExternalDocuments[1]["theDescription"])
   b.dbProxy.addExternalDocument(self.iec1)
   b.dbProxy.addExternalDocument(self.iec2)
   self.oecs = b.dbProxy.getExternalDocuments()
   self.iDocumentReferences = d['document_references']
   self.idr1 = DocumentReferenceParameters(self.iDocumentReferences[0]["theName"],self.iDocumentReferences[0]["theDocName"],self.iDocumentReferences[0]["theContributor"],self.iDocumentReferences[0]["theExcerpt"])
   self.idr2 = DocumentReferenceParameters(self.iDocumentReferences[1]["theName"],self.iDocumentReferences[1]["theDocName"],self.iDocumentReferences[1]["theContributor"],self.iDocumentReferences[1]["theExcerpt"])
   b.dbProxy.addDocumentReference(self.idr1)
   b.dbProxy.addDocumentReference(self.idr2)
   self.odrs = b.dbProxy.getDocumentReferences()
   self.iPersonaCharacteristics = d['persona_characteristics']
   self.ipc1 = PersonaCharacteristicParameters(self.iPersonaCharacteristics[0]["thePersonaName"],self.iPersonaCharacteristics[0]["theModQual"],self.iPersonaCharacteristics[0]["theVariable"],self.iPersonaCharacteristics[0]["theCharacteristic"],[(self.iPersonaCharacteristics[0]["ground"],'','document')],[(self.iPersonaCharacteristics[0]["warrant"],'','document')],[],[])
   b.dbProxy.addPersonaCharacteristic(self.ipc1)
   self.opcs = b.dbProxy.getPersonaCharacteristics()
   self.iAttackers = d['attackers']
   self.iatkeps = [AttackerEnvironmentProperties(self.iAttackers[0]["theEnvironmentProperties"][0]["theName"],self.iAttackers[0]["theEnvironmentProperties"][0]["theRoles"],self.iAttackers[0]["theEnvironmentProperties"][0]["theMotives"],self.iAttackers[0]["theEnvironmentProperties"][0]["theCapabilities"])]
   self.iatk = AttackerParameters(self.iAttackers[0]["theName"], self.iAttackers[0]["theDescription"], self.iAttackers[0]["theImage"],[],self.iatkeps)
   b.dbProxy.addAttacker(self.iatk)
   self.oAttackers = b.dbProxy.getAttackers()
   self.iVtypes = d['valuetypes']
   self.ivt = ValueTypeParameters(self.iVtypes[0]["theName"], self.iVtypes[0]["theDescription"], self.iVtypes[0]["theType"])
   b.dbProxy.addValueType(self.ivt)
   self.ovt = b.dbProxy.getValueTypes('threat_type')
   self.iassets = d['assets']
   self.iaeps = [AssetEnvironmentProperties(self.iassets[0]["theEnvironmentProperties"][0][0],self.iassets[0]["theEnvironmentProperties"][0][1],self.iassets[0]["theEnvironmentProperties"][0][2])]
   self.iap = AssetParameters(self.iassets[0]["theName"],self.iassets[0]["theShortCode"],self.iassets[0]["theDescription"],self.iassets[0]["theSignificance"],self.iassets[0]["theType"],"0","N/A",[],[],self.iaeps)
   b.dbProxy.addAsset(self.iap)
   self.oap = b.dbProxy.getAssets()
   self.iThreats = d['threats']
    def setUp(self):
        call([os.environ['CAIRIS_CFG_DIR'] + "/initdb.sh"])
        cairis.core.BorgFactory.initialise()
        f = open(os.environ['CAIRIS_SRC'] + '/test/policy_statements.json')
        d = json.load(f)
        f.close()
        ienvs = d['environments']
        iep1 = EnvironmentParameters(ienvs[0]["theName"],
                                     ienvs[0]["theShortCode"],
                                     ienvs[0]["theDescription"])
        b = Borg()
        b.dbProxy.addEnvironment(iep1)
        iassets = d['assets']
        iaeps1 = AssetEnvironmentProperties(
            iassets[0]["theEnvironmentProperties"][0][0],
            iassets[0]["theEnvironmentProperties"][0][1],
            iassets[0]["theEnvironmentProperties"][0][2])
        iap1 = AssetParameters(iassets[0]["theName"],
                               iassets[0]["theShortCode"],
                               iassets[0]["theDescription"],
                               iassets[0]["theSignificance"],
                               iassets[0]["theType"], "0", "N/A", [], [],
                               [iaeps1])
        b.dbProxy.addAsset(iap1)
        iaeps1 = AssetEnvironmentProperties(
            iassets[1]["theEnvironmentProperties"][0][0],
            iassets[1]["theEnvironmentProperties"][0][1],
            iassets[1]["theEnvironmentProperties"][0][2])
        iap2 = AssetParameters(iassets[1]["theName"],
                               iassets[1]["theShortCode"],
                               iassets[1]["theDescription"],
                               iassets[1]["theSignificance"],
                               iassets[1]["theType"], "0", "N/A", [], [],
                               [iaeps1])
        b.dbProxy.addAsset(iap2)
        self.iGoals = d['goals']

        igep1d = GoalEnvironmentProperties(
            self.iGoals[0]["theEnvironmentProperties"][0]["theName"],
            self.iGoals[0]["theEnvironmentProperties"][0]["theLabel"],
            self.iGoals[0]["theEnvironmentProperties"][0]["theDefinition"],
            self.iGoals[0]["theEnvironmentProperties"][0]["theCategory"],
            self.iGoals[0]["theEnvironmentProperties"][0]["thePriority"],
            self.iGoals[0]["theEnvironmentProperties"][0]["theFitCriterion"],
            self.iGoals[0]["theEnvironmentProperties"][0]["theIssue"], [], [],
            self.iGoals[0]["theEnvironmentProperties"][0]["theConcerns"], [])
        igp1 = GoalParameters(self.iGoals[0]["theName"],
                              self.iGoals[0]["theOriginator"], [], [igep1d])
        b.dbProxy.addGoal(igp1)
        self.iPs = d['policy_statements']
Exemplo n.º 14
0
  def endElement(self,name):
    if name == 'entry':
      self.theNamingConventions.append((self.theCurrentNameEntry,self.theDefinition))
    elif name == 'revision':
      self.theRevisions.append((self.theCurrentRevNo,self.theCurrentRevDate,self.theRemarks))
    elif name == 'project_settings':
      self.theProjectSettings = (self.theName,self.theBackground,self.theStrategicGoals,self.theScope,self.theNamingConventions,self.theContributors,self.theRevisions,self.theRichPicture)
    elif name == 'asset_values':
      nv = ValueTypeParameters('None',self.theNoneValue,'asset_value',self.theName)
      nv.setId(0)
      self.theAssetValues.append(nv)

      lv = ValueTypeParameters('Low',self.theLowValue,'asset_value',self.theName)
      lv.setId(1)
      self.theAssetValues.append(lv)

      mv = ValueTypeParameters('Medium',self.theMedValue,'asset_value',self.theName)
      mv.setId(2)
      self.theAssetValues.append(mv)

      hv = ValueTypeParameters('High',self.theHighValue,'asset_value',self.theName)
      hv.setId(3)
      self.theAssetValues.append(hv)

      self.resetAssetValues()
    elif name == 'environment':
      p = EnvironmentParameters(self.theName,self.theShortCode,self.theDefinition,self.theCompositeEnvironments,self.theDuplicateProperty,self.theOverridingEnvironment)
      p.setAssetValues(self.theAssetValues)
      self.theEnvironments.append(p)
      self.resetEnvironmentAttributes()
    elif name == 'background':
      self.inBackground = 0
    elif name == 'strategic_goals':
      self.inStrategicGoals = 0
    elif name == 'scope':
      self.inScope = 0
    elif name == 'definition':
      self.inDefinition = 0
    elif name == 'remarks':
      self.inRemarks = 0
    elif name == 'none':
      self.inNone = 0
    elif name == 'low':
      self.inLow = 0
    elif name == 'medium':
      self.inMed = 0
    elif name == 'high':
      self.inHigh = 0
Exemplo n.º 15
0
  def setUp(self):
    call([os.environ['CAIRIS_SRC'] + "/test/initdb.sh"])
    cairis.core.BorgFactory.initialise()
    f = open(os.environ['CAIRIS_SRC'] + '/test/usecases.json')
    d = json.load(f)
    f.close()
    self.iEnvironments = d['environments']
    iep1 = EnvironmentParameters(self.iEnvironments[0]["theName"],self.iEnvironments[0]["theShortCode"],self.iEnvironments[0]["theDescription"])
    b = Borg()
    b.dbProxy.addEnvironment(iep1)
    self.theEnvironments = b.dbProxy.getEnvironments()

    self.iRoles = d['roles']
    irp = RoleParameters(self.iRoles[0]["theName"], self.iRoles[0]["theType"], self.iRoles[0]["theShortCode"], self.iRoles[0]["theDescription"],[])
    b.dbProxy.addRole(irp)
    self.theRoles = b.dbProxy.getRoles()

    self.iUseCases = d['use_cases']
Exemplo n.º 16
0
 def setUp(self):
     call([os.environ['CAIRIS_CFG_DIR'] + "/initdb.sh"])
     cairis.core.BorgFactory.initialise()
     f = open(os.environ['CAIRIS_SRC'] + '/test/processes.json')
     d = json.load(f)
     f.close()
     iCodes = d['codes']
     i = CodeParameters(iCodes[0]["theName"], iCodes[0]["theType"],
                        iCodes[0]["theDescription"],
                        iCodes[0]["theInclusionCriteria"],
                        iCodes[0]["theExample"])
     b = Borg()
     b.dbProxy.addCode(i)
     i = CodeParameters(iCodes[1]["theName"], iCodes[1]["theType"],
                        iCodes[1]["theDescription"],
                        iCodes[1]["theInclusionCriteria"],
                        iCodes[1]["theExample"])
     b.dbProxy.addCode(i)
     iEnvironments = d['environments']
     iep1 = EnvironmentParameters(iEnvironments[0]["theName"],
                                  iEnvironments[0]["theShortCode"],
                                  iEnvironments[0]["theDescription"])
     b.dbProxy.addEnvironment(iep1)
     iRoles = d['roles']
     irp = RoleParameters(iRoles[0]["theName"], iRoles[0]["theType"],
                          iRoles[0]["theShortCode"],
                          iRoles[0]["theDescription"], [])
     b.dbProxy.addRole(irp)
     iPersonas = d['personas']
     ipp = PersonaParameters(
         iPersonas[0]["theName"], iPersonas[0]["theActivities"],
         iPersonas[0]["theAttitudes"], iPersonas[0]["theAptitudes"],
         iPersonas[0]["theMotivations"], iPersonas[0]["theSkills"],
         iPersonas[0]["theIntrinsic"], iPersonas[0]["theContextual"], "",
         "0", iPersonas[0]["thePersonaType"], [], [
             PersonaEnvironmentProperties(
                 iPersonas[0]["theEnvironmentProperties"][0]["theName"],
                 (iPersonas[0]["theEnvironmentProperties"][0]
                  ["theDirectFlag"] == "True"), iPersonas[0]
                 ["theEnvironmentProperties"][0]["theNarrative"],
                 iPersonas[0]["theEnvironmentProperties"][0]["theRole"])
         ], [])
     b.dbProxy.addPersona(ipp)
     self.iCN = d['code_networks']
Exemplo n.º 17
0
  def setUp(self):
    call([os.environ['CAIRIS_CFG_DIR'] + "/initdb.sh"])
    cairis.core.BorgFactory.initialise()
    f = open(os.environ['CAIRIS_SRC'] + '/test/countermeasures.json')
    d = json.load(f)
    f.close()
    ienvs = d['environments']
    iep1 = EnvironmentParameters(ienvs[0]["theName"],ienvs[0]["theShortCode"],ienvs[0]["theDescription"])
    b = Borg()
    b.dbProxy.addEnvironment(iep1)
    iRoles = d['roles']
    irp = RoleParameters(iRoles[0]["theName"], iRoles[0]["theType"], iRoles[0]["theShortCode"], iRoles[0]["theDescription"],[])
    b.dbProxy.addRole(irp)
    iPersonas = d['personas']
    ipp = PersonaParameters(iPersonas[0]["theName"],iPersonas[0]["theActivities"],iPersonas[0]["theAttitudes"],iPersonas[0]["theAptitudes"],iPersonas[0]["theMotivations"],iPersonas[0]["theSkills"],iPersonas[0]["theIntrinsic"],iPersonas[0]["theContextual"],"","0",iPersonas[0]["thePersonaType"],[],[PersonaEnvironmentProperties(iPersonas[0]["theEnvironmentProperties"][0]["theName"],(iPersonas[0]["theEnvironmentProperties"][0]["theDirectFlag"] == "True"),iPersonas[0]["theEnvironmentProperties"][0]["theNarrative"],iPersonas[0]["theEnvironmentProperties"][0]["theRole"])],[])
    b.dbProxy.addPersona(ipp)
    iAttackers = d['attackers']
    iatkeps = [AttackerEnvironmentProperties(iAttackers[0]["theEnvironmentProperties"][0]["theName"],iAttackers[0]["theEnvironmentProperties"][0]["theRoles"],iAttackers[0]["theEnvironmentProperties"][0]["theMotives"],iAttackers[0]["theEnvironmentProperties"][0]["theCapabilities"])]
    iatk = AttackerParameters(iAttackers[0]["theName"], iAttackers[0]["theDescription"], iAttackers[0]["theImage"],[],iatkeps)
    b.dbProxy.addAttacker(iatk)
    iVtypes = d['valuetypes']
    ivt1 = ValueTypeParameters(iVtypes[0]["theName"], iVtypes[0]["theDescription"], iVtypes[0]["theType"])
    ivt2 = ValueTypeParameters(iVtypes[1]["theName"], iVtypes[1]["theDescription"], iVtypes[1]["theType"])
    b.dbProxy.addValueType(ivt1)
    b.dbProxy.addValueType(ivt2)
    iassets = d['assets']
    iaeps1 = [AssetEnvironmentProperties(iassets[0]["theEnvironmentProperties"][0][0],iassets[0]["theEnvironmentProperties"][0][1],iassets[0]["theEnvironmentProperties"][0][2])]
    iaeps2 = [AssetEnvironmentProperties(iassets[1]["theEnvironmentProperties"][0][0],iassets[1]["theEnvironmentProperties"][0][1],iassets[1]["theEnvironmentProperties"][0][2])]
    iaeps3 = [AssetEnvironmentProperties(iassets[2]["theEnvironmentProperties"][0][0],iassets[2]["theEnvironmentProperties"][0][1],iassets[2]["theEnvironmentProperties"][0][2])]
    iap1 = AssetParameters(iassets[0]["theName"],iassets[0]["theShortCode"],iassets[0]["theDescription"],iassets[0]["theSignificance"],iassets[0]["theType"],"0","N/A",[],[],iaeps1)
    iap2 = AssetParameters(iassets[1]["theName"],iassets[1]["theShortCode"],iassets[1]["theDescription"],iassets[1]["theSignificance"],iassets[1]["theType"],"0","N/A",[],[],iaeps2)
    iap3 = AssetParameters(iassets[2]["theName"],iassets[2]["theShortCode"],iassets[2]["theDescription"],iassets[2]["theSignificance"],iassets[2]["theType"],"0","N/A",[],[],iaeps3)
    b.dbProxy.addAsset(iap1)
    b.dbProxy.addAsset(iap2)
    b.dbProxy.addAsset(iap3)
    iThreats = d['threats']
    iteps = [ThreatEnvironmentProperties(iThreats[0]["theEnvironmentProperties"][0]["theName"],iThreats[0]["theEnvironmentProperties"][0]["theLikelihood"],iThreats[0]["theEnvironmentProperties"][0]["theAssets"],iThreats[0]["theEnvironmentProperties"][0]["theAttackers"],iThreats[0]["theEnvironmentProperties"][0]["theProperties"][0][1],iThreats[0]["theEnvironmentProperties"][0]["theProperties"][0][1])]
    itps = ThreatParameters(iThreats[0]["theName"],iThreats[0]["theType"],iThreats[0]["theMethod"],[],iteps)
    b.dbProxy.addThreat(itps)
    iVuln = d['vulnerabilities']
    iveps = [VulnerabilityEnvironmentProperties(iVuln[0]["theEnvironmentProperties"][0]["theName"],iVuln[0]["theEnvironmentProperties"][0]["theSeverity"],iVuln[0]["theEnvironmentProperties"][0]["theAssets"])]
    ivp = VulnerabilityParameters(iVuln[0]["theName"],iVuln[0]["theDescription"],iVuln[0]["theType"], [], iveps)
    b.dbProxy.addVulnerability(ivp)
    imc = d['misuseCase']
    iRisks = d['risks']
    imcep = [MisuseCaseEnvironmentProperties(imc[0]["theEnvironmentProperties"][0]["theName"],imc[0]["theEnvironmentProperties"][0]["theDescription"])]
    imcp = MisuseCase(int(0), imc[0]["theName"], imcep,imc[0]["theRisk"])
    irp = RiskParameters(iRisks[0]["theName"],iRisks[0]["threatName"],iRisks[0]["vulName"], imcp,[])
    b.dbProxy.addRisk(irp)
    iResponses = d['responses']
    iar1Name = iResponses[0]["theType"] + " " + iResponses[0]["theRisk"] 
    iaep1 = AcceptEnvironmentProperties(iResponses[0]["theEnvironmentProperties"][0],iResponses[0]["theEnvironmentProperties"][1],iResponses[0]["theEnvironmentProperties"][2])
    iar1 = ResponseParameters(iar1Name,iResponses[0]["theRisk"],[],[iaep1], iResponses[0]["theType"])

    iar2Name = iResponses[1]["theType"] + " " + iResponses[1]["theRisk"] 
    iaep2 = MitigateEnvironmentProperties(iResponses[1]["theEnvironmentProperties"],iResponses[1]["theType"])
    iar2 = ResponseParameters(iar2Name,iResponses[1]["theRisk"],[],[iaep2], iResponses[1]["theType"])

    b.dbProxy.addResponse(iar1)
    b.dbProxy.addResponse(iar2)

    ors = b.dbProxy.getResponses()
    oar1 = ors[iar1Name]
    oar2 = ors[iar2Name]

    rgp = cairis.core.GoalFactory.build(oar2)
    riskParameters = rgp[0]
    riskGoalId = b.dbProxy.addGoal(riskParameters)
    b.dbProxy.addTrace('response_goal',oar2.id(),riskGoalId)
    if (len(rgp) > 1):
      threatParameters = rgp[1]
      vulnerabilityParameters = rgp[2]
      b.dbProxy.addGoal(vulnerabilityParameters)
      b.dbProxy.addGoal(threatParameters)
    b.dbProxy.relabelGoals(iaep2.name())

    oGoals = b.dbProxy.getGoals()
    rg = oGoals['Deter' + oar2.risk()]
    vg = oGoals[vulnerabilityParameters.name()]
    tg = oGoals[threatParameters.name()]

    reqId = b.dbProxy.newId()
    irequirements = d['requirements']
    ireq = cairis.core.RequirementFactory.build(reqId,irequirements[0]["theLabel"],irequirements[0]["theName"],irequirements[0]["theDescription"],irequirements[0]["thePriority"],irequirements[0]["theRationale"],irequirements[0]["theFitCriterion"],irequirements[0]["theOriginator"],irequirements[0]["theType"],irequirements[0]["theReference"],1)
    b.dbProxy.addRequirement(ireq,irequirements[0]["theReference"],True)

    oreqs = b.dbProxy.getRequirements()
    oreq = oreqs[ireq.description()]

    iga = GoalAssociationParameters(iaep2.name(),vg.name(),'goal','and',oreq.name(),'requirement',0,'None')
    b.dbProxy.addGoalAssociation(iga)
    ogops = b.dbProxy.getGoalAssociations()
    self.ogop3 = ogops[iaep2.name() + '/' + vg.name() + '/' + oreq.name() + '/and']
    self.iCountermeasures = d['countermeasures']
Exemplo n.º 18
0
    def setUp(self):
        call([os.environ['CAIRIS_CFG_DIR'] + "/initdb.sh"])
        cairis.core.BorgFactory.initialise()
        f = open(os.environ['CAIRIS_SRC'] + '/test/responses.json')
        d = json.load(f)
        f.close()
        ienvs = d['environments']
        iep1 = EnvironmentParameters(ienvs[0]["theName"],
                                     ienvs[0]["theShortCode"],
                                     ienvs[0]["theDescription"])
        b = Borg()
        b.dbProxy.addEnvironment(iep1)
        iRoles = d['roles']
        irp = RoleParameters(iRoles[0]["theName"], iRoles[0]["theType"],
                             iRoles[0]["theShortCode"],
                             iRoles[0]["theDescription"], [])
        b.dbProxy.addRole(irp)
        iAttackers = d['attackers']
        iatkeps = [
            AttackerEnvironmentProperties(
                iAttackers[0]["theEnvironmentProperties"][0]["theName"],
                iAttackers[0]["theEnvironmentProperties"][0]["theRoles"],
                iAttackers[0]["theEnvironmentProperties"][0]["theMotives"],
                iAttackers[0]["theEnvironmentProperties"][0]
                ["theCapabilities"])
        ]
        iatk = AttackerParameters(iAttackers[0]["theName"],
                                  iAttackers[0]["theDescription"],
                                  iAttackers[0]["theImage"], [], iatkeps)
        b.dbProxy.addAttacker(iatk)
        iVtypes = d['valuetypes']
        ivt1 = ValueTypeParameters(iVtypes[0]["theName"],
                                   iVtypes[0]["theDescription"],
                                   iVtypes[0]["theType"])
        ivt2 = ValueTypeParameters(iVtypes[1]["theName"],
                                   iVtypes[1]["theDescription"],
                                   iVtypes[1]["theType"])
        b.dbProxy.addValueType(ivt1)
        b.dbProxy.addValueType(ivt2)
        iassets = d['assets']
        iaeps1 = [
            AssetEnvironmentProperties(
                iassets[0]["theEnvironmentProperties"][0][0],
                iassets[0]["theEnvironmentProperties"][0][1],
                iassets[0]["theEnvironmentProperties"][0][2])
        ]
        iaeps2 = [
            AssetEnvironmentProperties(
                iassets[1]["theEnvironmentProperties"][0][0],
                iassets[1]["theEnvironmentProperties"][0][1],
                iassets[1]["theEnvironmentProperties"][0][2])
        ]
        iaeps3 = [
            AssetEnvironmentProperties(
                iassets[2]["theEnvironmentProperties"][0][0],
                iassets[2]["theEnvironmentProperties"][0][1],
                iassets[2]["theEnvironmentProperties"][0][2])
        ]
        iap1 = AssetParameters(iassets[0]["theName"],
                               iassets[0]["theShortCode"],
                               iassets[0]["theDescription"],
                               iassets[0]["theSignificance"],
                               iassets[0]["theType"], "0", "N/A", [], [],
                               iaeps1)
        iap2 = AssetParameters(iassets[1]["theName"],
                               iassets[1]["theShortCode"],
                               iassets[1]["theDescription"],
                               iassets[1]["theSignificance"],
                               iassets[1]["theType"], "0", "N/A", [], [],
                               iaeps2)
        iap3 = AssetParameters(iassets[2]["theName"],
                               iassets[2]["theShortCode"],
                               iassets[2]["theDescription"],
                               iassets[2]["theSignificance"],
                               iassets[2]["theType"], "0", "N/A", [], [],
                               iaeps3)
        b.dbProxy.addAsset(iap1)
        b.dbProxy.addAsset(iap2)
        b.dbProxy.addAsset(iap3)
        iThreats = d['threats']
        iteps = [
            ThreatEnvironmentProperties(
                iThreats[0]["theEnvironmentProperties"][0]["theName"],
                iThreats[0]["theEnvironmentProperties"][0]["theLikelihood"],
                iThreats[0]["theEnvironmentProperties"][0]["theAssets"],
                iThreats[0]["theEnvironmentProperties"][0]["theAttackers"],
                iThreats[0]["theEnvironmentProperties"][0]["theProperties"][0]
                [1], iThreats[0]["theEnvironmentProperties"][0]
                ["theProperties"][0][1])
        ]
        itps = ThreatParameters(iThreats[0]["theName"], iThreats[0]["theType"],
                                iThreats[0]["theMethod"], [], iteps)
        b.dbProxy.addThreat(itps)
        iVuln = d['vulnerabilities']
        iveps = [
            VulnerabilityEnvironmentProperties(
                iVuln[0]["theEnvironmentProperties"][0]["theName"],
                iVuln[0]["theEnvironmentProperties"][0]["theSeverity"],
                iVuln[0]["theEnvironmentProperties"][0]["theAssets"])
        ]
        ivp = VulnerabilityParameters(iVuln[0]["theName"],
                                      iVuln[0]["theDescription"],
                                      iVuln[0]["theType"], [], iveps)
        b.dbProxy.addVulnerability(ivp)
        imc = d['misuseCase']
        iRisks = d['risks']

        imcep = [
            MisuseCaseEnvironmentProperties(
                imc[0]["theEnvironmentProperties"][0]["theName"],
                imc[0]["theEnvironmentProperties"][0]["theDescription"])
        ]
        imcp = MisuseCase(int(0), imc[0]["theName"], imcep, imc[0]["theRisk"])
        irp = RiskParameters(iRisks[0]["theName"], iRisks[0]["threatName"],
                             iRisks[0]["vulName"], imcp, [])
        b.dbProxy.addRisk(irp)
        self.iResponses = d['responses']
Exemplo n.º 19
0
    def setUp(self):
        call([os.environ['CAIRIS_CFG_DIR'] + "/initdb.sh"])
        cairis.core.BorgFactory.initialise()
        f = open(os.environ['CAIRIS_SRC'] + '/test/processes.json')
        d = json.load(f)
        f.close()

        b = Borg()
        iIntDocs = d['internaldocuments']
        i = InternalDocumentParameters(iIntDocs[0]["theName"],
                                       iIntDocs[0]["theDescription"],
                                       iIntDocs[0]["theContent"], [], [])
        b.dbProxy.addInternalDocument(i)

        iCodes = d['codes']
        i = CodeParameters(iCodes[0]["theName"], iCodes[0]["theType"],
                           iCodes[0]["theDescription"],
                           iCodes[0]["theInclusionCriteria"],
                           iCodes[0]["theExample"])
        b.dbProxy.addCode(i)
        i = CodeParameters(iCodes[1]["theName"], iCodes[1]["theType"],
                           iCodes[1]["theDescription"],
                           iCodes[1]["theInclusionCriteria"],
                           iCodes[1]["theExample"])
        b.dbProxy.addCode(i)
        iQs = d['quotations']
        i = (iQs[0]["theType"], iQs[0]["theCode"], iQs[0]["theArtifactType"],
             iQs[0]["theArtifactName"], iQs[0]["theEnvironment"],
             iQs[0]["theSection"], iQs[0]["theStartIdx"], iQs[0]["theEndIdx"],
             iQs[0]["theLabel"], iQs[0]["theSynopsis"])
        b.dbProxy.addQuotation(i)
        i = (iQs[2]['theType'], iQs[2]["theCode"], iQs[2]["theArtifactType"],
             iQs[2]["theArtifactName"], iQs[2]["theEnvironment"],
             iQs[2]["theSection"], iQs[2]["theStartIdx"], iQs[2]["theEndIdx"],
             iQs[2]["theLabel"], iQs[2]["theSynopsis"])
        b.dbProxy.addQuotation(i)
        iEnvironments = d['environments']
        iep1 = EnvironmentParameters(iEnvironments[0]["theName"],
                                     iEnvironments[0]["theShortCode"],
                                     iEnvironments[0]["theDescription"])
        b.dbProxy.addEnvironment(iep1)
        iRoles = d['roles']
        irp = RoleParameters(iRoles[0]["theName"], iRoles[0]["theType"],
                             iRoles[0]["theShortCode"],
                             iRoles[0]["theDescription"], [])
        b.dbProxy.addRole(irp)
        iPersonas = d['personas']
        ipp = PersonaParameters(
            iPersonas[0]["theName"], iPersonas[0]["theActivities"],
            iPersonas[0]["theAttitudes"], iPersonas[0]["theAptitudes"],
            iPersonas[0]["theMotivations"], iPersonas[0]["theSkills"],
            iPersonas[0]["theIntrinsic"], iPersonas[0]["theContextual"], "",
            "0", iPersonas[0]["thePersonaType"], [], [
                PersonaEnvironmentProperties(
                    iPersonas[0]["theEnvironmentProperties"][0]["theName"],
                    (iPersonas[0]["theEnvironmentProperties"][0]
                     ["theDirectFlag"] == "True"), iPersonas[0]
                    ["theEnvironmentProperties"][0]["theNarrative"],
                    iPersonas[0]["theEnvironmentProperties"][0]["theRole"])
            ], [])
        b.dbProxy.addPersona(ipp)
        self.iCN = d['code_networks']
        b.dbProxy.addCodeRelationship(self.iCN[0]["thePersonaName"],
                                      self.iCN[0]["theFromCode"],
                                      self.iCN[0]["theToCode"],
                                      self.iCN[0]["theRshipType"])
Exemplo n.º 20
0
 def setUp(self):
     call([os.environ['CAIRIS_CFG_DIR'] + "/initdb.sh"])
     cairis.core.BorgFactory.initialise()
     f = open(os.environ['CAIRIS_SRC'] + '/test/threats.json')
     d = json.load(f)
     f.close()
     ienvs = d['environments']
     iep = EnvironmentParameters(ienvs[0]["theName"],
                                 ienvs[0]["theShortCode"],
                                 ienvs[0]["theDescription"])
     iep1 = EnvironmentParameters(ienvs[1]["theName"],
                                  ienvs[1]["theShortCode"],
                                  ienvs[1]["theDescription"])
     b = Borg()
     b.dbProxy.addEnvironment(iep)
     b.dbProxy.addEnvironment(iep1)
     iRoles = d['roles']
     irp = RoleParameters(iRoles[0]["theName"], iRoles[0]["theType"],
                          iRoles[0]["theShortCode"],
                          iRoles[0]["theDescription"], [])
     b.dbProxy.addRole(irp)
     iAttackers = d['attackers']
     iatkeps = [
         AttackerEnvironmentProperties(
             iAttackers[0]["theEnvironmentProperties"][0]["theName"],
             iAttackers[0]["theEnvironmentProperties"][0]["theRoles"],
             iAttackers[0]["theEnvironmentProperties"][0]["theMotives"],
             iAttackers[0]["theEnvironmentProperties"][0]
             ["theCapabilities"]),
         AttackerEnvironmentProperties(
             iAttackers[0]["theEnvironmentProperties"][1]["theName"],
             iAttackers[0]["theEnvironmentProperties"][1]["theRoles"],
             iAttackers[0]["theEnvironmentProperties"][1]["theMotives"],
             iAttackers[0]["theEnvironmentProperties"][1]
             ["theCapabilities"])
     ]
     iatk = AttackerParameters(iAttackers[0]["theName"],
                               iAttackers[0]["theDescription"],
                               iAttackers[0]["theImage"], [], iatkeps)
     b.dbProxy.addAttacker(iatk)
     iVtypes = d['valuetypes']
     ivt = ValueTypeParameters(iVtypes[0]["theName"],
                               iVtypes[0]["theDescription"],
                               iVtypes[0]["theType"])
     b.dbProxy.addValueType(ivt)
     iassets = d['assets']
     iaeps = [
         AssetEnvironmentProperties(
             iassets[0]["theEnvironmentProperties"][0][0],
             iassets[0]["theEnvironmentProperties"][0][1],
             iassets[0]["theEnvironmentProperties"][0][2]),
         AssetEnvironmentProperties(
             iassets[0]["theEnvironmentProperties"][1][0],
             iassets[0]["theEnvironmentProperties"][1][1],
             iassets[0]["theEnvironmentProperties"][1][2])
     ]
     iap = AssetParameters(iassets[0]["theName"],
                           iassets[0]["theShortCode"],
                           iassets[0]["theDescription"],
                           iassets[0]["theSignificance"],
                           iassets[0]["theType"], "0", "N/A", [], [], iaeps)
     b.dbProxy.addAsset(iap)
     self.iThreats = d['threats']
Exemplo n.º 21
0
    def setUp(self):
        call([os.environ['CAIRIS_CFG_DIR'] + "/initdb.sh"])
        cairis.core.BorgFactory.initialise()
        f = open(os.environ['CAIRIS_SRC'] + '/test/tasks.json')
        d = json.load(f)
        f.close()
        iEnvironments = d['environments']
        iep1 = EnvironmentParameters(iEnvironments[0]["theName"],
                                     iEnvironments[0]["theShortCode"],
                                     iEnvironments[0]["theDescription"])
        iep2 = EnvironmentParameters(iEnvironments[1]["theName"],
                                     iEnvironments[1]["theShortCode"],
                                     iEnvironments[1]["theDescription"])
        b = Borg()
        b.dbProxy.addEnvironment(iep1)
        b.dbProxy.addEnvironment(iep2)

        iRoles = d['roles']
        irp = RoleParameters(iRoles[0]["theName"], iRoles[0]["theType"],
                             iRoles[0]["theShortCode"],
                             iRoles[0]["theDescription"], [])
        b.dbProxy.addRole(irp)
        iPersonas = d['personas']
        ipp = PersonaParameters(
            iPersonas[0]["theName"], iPersonas[0]["theActivities"],
            iPersonas[0]["theAttitudes"], iPersonas[0]["theAptitudes"],
            iPersonas[0]["theMotivations"], iPersonas[0]["theSkills"],
            iPersonas[0]["theIntrinsic"], iPersonas[0]["theContextual"], "",
            "0", iPersonas[0]["thePersonaType"], [], [
                PersonaEnvironmentProperties(
                    iPersonas[0]["theEnvironmentProperties"][0]["theName"],
                    (iPersonas[0]["theEnvironmentProperties"][0]
                     ["theDirectFlag"] == "True"), iPersonas[0]
                    ["theEnvironmentProperties"][0]["theNarrative"],
                    iPersonas[0]["theEnvironmentProperties"][0]["theRole"]),
                PersonaEnvironmentProperties(
                    iPersonas[0]["theEnvironmentProperties"][1]["theName"],
                    (iPersonas[0]["theEnvironmentProperties"][1]
                     ["theDirectFlag"] == "True"), iPersonas[0]
                    ["theEnvironmentProperties"][1]["theNarrative"],
                    iPersonas[0]["theEnvironmentProperties"][1]["theRole"])
            ], [])
        b.dbProxy.addPersona(ipp)

        iAssets = d['assets']
        iaeps = [
            AssetEnvironmentProperties(
                iAssets[0]["theEnvironmentProperties"][0][0],
                iAssets[0]["theEnvironmentProperties"][0][1],
                iAssets[0]["theEnvironmentProperties"][0][2]),
            AssetEnvironmentProperties(
                iAssets[0]["theEnvironmentProperties"][1][0],
                iAssets[0]["theEnvironmentProperties"][1][1],
                iAssets[0]["theEnvironmentProperties"][1][2])
        ]
        iap = AssetParameters(iAssets[0]["theName"],
                              iAssets[0]["theShortCode"],
                              iAssets[0]["theDescription"],
                              iAssets[0]["theSignificance"],
                              iAssets[0]["theType"], "0", "N/A", [], [], iaeps)
        b = Borg()
        b.dbProxy.addAsset(iap)
        self.iTasks = d['tasks']
Exemplo n.º 22
0
 def parameters(self):
     parameters = EnvironmentParameters(self.environmentName,
                                        self.environmentShortCode,
                                        self.environmentDescription)
     parameters.setId(self.theEnvironmentId)
     return parameters
Exemplo n.º 23
0
    def setUp(self):
        call([os.environ['CAIRIS_SRC'] + "/test/initdb.sh"])
        cairis.core.BorgFactory.initialise()
        f = open(os.environ['CAIRIS_SRC'] + '/test/countermeasures.json')
        d = json.load(f)
        f.close()
        self.ienvs = d['environments']
        self.iep1 = EnvironmentParameters(self.ienvs[0]["theName"],
                                          self.ienvs[0]["theShortCode"],
                                          self.ienvs[0]["theDescription"])
        b = Borg()
        b.dbProxy.addEnvironment(self.iep1)
        self.oenvs = b.dbProxy.getEnvironments()
        self.iRoles = d['roles']
        self.irp = RoleParameters(self.iRoles[0]["theName"],
                                  self.iRoles[0]["theType"],
                                  self.iRoles[0]["theShortCode"],
                                  self.iRoles[0]["theDescription"], [])
        b.dbProxy.addRole(self.irp)
        self.oRoles = b.dbProxy.getRoles()
        self.iPersonas = d['personas']
        self.ipp = PersonaParameters(
            self.iPersonas[0]["theName"], self.iPersonas[0]["theActivities"],
            self.iPersonas[0]["theAttitudes"],
            self.iPersonas[0]["theAptitudes"],
            self.iPersonas[0]["theMotivations"],
            self.iPersonas[0]["theSkills"], self.iPersonas[0]["theIntrinsic"],
            self.iPersonas[0]["theContextual"], "", "0",
            self.iPersonas[0]["thePersonaType"], [], [
                PersonaEnvironmentProperties(
                    self.iPersonas[0]["theEnvironmentProperties"][0]
                    ["theName"], (self.iPersonas[0]["theEnvironmentProperties"]
                                  [0]["theDirectFlag"] == "True"),
                    self.iPersonas[0]["theEnvironmentProperties"][0]
                    ["theNarrative"], self.iPersonas[0]
                    ["theEnvironmentProperties"][0]["theRole"])
            ], [])
        b.dbProxy.addPersona(self.ipp)
        self.opp = b.dbProxy.getPersonas()
        self.iExternalDocuments = d['external_documents']
        self.iec1 = ExternalDocumentParameters(
            self.iExternalDocuments[0]["theName"],
            self.iExternalDocuments[0]["theVersion"],
            self.iExternalDocuments[0]["thePublicationDate"],
            self.iExternalDocuments[0]["theAuthors"],
            self.iExternalDocuments[0]["theDescription"])
        self.iec2 = ExternalDocumentParameters(
            self.iExternalDocuments[1]["theName"],
            self.iExternalDocuments[1]["theVersion"],
            self.iExternalDocuments[1]["thePublicationDate"],
            self.iExternalDocuments[1]["theAuthors"],
            self.iExternalDocuments[1]["theDescription"])
        b.dbProxy.addExternalDocument(self.iec1)
        b.dbProxy.addExternalDocument(self.iec2)
        self.oecs = b.dbProxy.getExternalDocuments()
        self.iDocumentReferences = d['document_references']
        self.idr1 = DocumentReferenceParameters(
            self.iDocumentReferences[0]["theName"],
            self.iDocumentReferences[0]["theDocName"],
            self.iDocumentReferences[0]["theContributor"],
            self.iDocumentReferences[0]["theExcerpt"])
        self.idr2 = DocumentReferenceParameters(
            self.iDocumentReferences[1]["theName"],
            self.iDocumentReferences[1]["theDocName"],
            self.iDocumentReferences[1]["theContributor"],
            self.iDocumentReferences[1]["theExcerpt"])
        b.dbProxy.addDocumentReference(self.idr1)
        b.dbProxy.addDocumentReference(self.idr2)
        self.odrs = b.dbProxy.getDocumentReferences()
        self.iPersonaCharacteristics = d['persona_characteristics']
        self.ipc1 = PersonaCharacteristicParameters(
            self.iPersonaCharacteristics[0]["thePersonaName"],
            self.iPersonaCharacteristics[0]["theModQual"],
            self.iPersonaCharacteristics[0]["theVariable"],
            self.iPersonaCharacteristics[0]["theCharacteristic"],
            [(self.iPersonaCharacteristics[0]["ground"], '', 'document')],
            [(self.iPersonaCharacteristics[0]["warrant"], '', 'document')], [],
            [])
        b.dbProxy.addPersonaCharacteristic(self.ipc1)
        self.opcs = b.dbProxy.getPersonaCharacteristics()
        self.iAttackers = d['attackers']
        self.iatkeps = [
            AttackerEnvironmentProperties(
                self.iAttackers[0]["theEnvironmentProperties"][0]["theName"],
                self.iAttackers[0]["theEnvironmentProperties"][0]["theRoles"],
                self.iAttackers[0]["theEnvironmentProperties"][0]
                ["theMotives"], self.iAttackers[0]["theEnvironmentProperties"]
                [0]["theCapabilities"])
        ]
        self.iatk = AttackerParameters(self.iAttackers[0]["theName"],
                                       self.iAttackers[0]["theDescription"],
                                       self.iAttackers[0]["theImage"], [],
                                       self.iatkeps)
        b.dbProxy.addAttacker(self.iatk)
        self.oAttackers = b.dbProxy.getAttackers()
        self.iVtypes = d['valuetypes']
        self.ivt1 = ValueTypeParameters(self.iVtypes[0]["theName"],
                                        self.iVtypes[0]["theDescription"],
                                        self.iVtypes[0]["theType"])
        self.ivt2 = ValueTypeParameters(self.iVtypes[1]["theName"],
                                        self.iVtypes[1]["theDescription"],
                                        self.iVtypes[1]["theType"])
        b.dbProxy.addValueType(self.ivt1)
        b.dbProxy.addValueType(self.ivt2)
        self.ovtt = b.dbProxy.getValueTypes('threat_type')
        self.ovtv = b.dbProxy.getValueTypes('vulnerability_type')
        self.iassets = d['assets']
        self.iaeps1 = [
            AssetEnvironmentProperties(
                self.iassets[0]["theEnvironmentProperties"][0][0],
                self.iassets[0]["theEnvironmentProperties"][0][1],
                self.iassets[0]["theEnvironmentProperties"][0][2])
        ]
        self.iaeps2 = [
            AssetEnvironmentProperties(
                self.iassets[1]["theEnvironmentProperties"][0][0],
                self.iassets[1]["theEnvironmentProperties"][0][1],
                self.iassets[1]["theEnvironmentProperties"][0][2])
        ]
        self.iaeps3 = [
            AssetEnvironmentProperties(
                self.iassets[2]["theEnvironmentProperties"][0][0],
                self.iassets[2]["theEnvironmentProperties"][0][1],
                self.iassets[2]["theEnvironmentProperties"][0][2])
        ]
        self.iap1 = AssetParameters(self.iassets[0]["theName"],
                                    self.iassets[0]["theShortCode"],
                                    self.iassets[0]["theDescription"],
                                    self.iassets[0]["theSignificance"],
                                    self.iassets[0]["theType"], "0", "N/A", [],
                                    [], self.iaeps1)
        self.iap2 = AssetParameters(self.iassets[1]["theName"],
                                    self.iassets[1]["theShortCode"],
                                    self.iassets[1]["theDescription"],
                                    self.iassets[1]["theSignificance"],
                                    self.iassets[1]["theType"], "0", "N/A", [],
                                    [], self.iaeps2)
        self.iap3 = AssetParameters(self.iassets[2]["theName"],
                                    self.iassets[2]["theShortCode"],
                                    self.iassets[2]["theDescription"],
                                    self.iassets[2]["theSignificance"],
                                    self.iassets[2]["theType"], "0", "N/A", [],
                                    [], self.iaeps3)
        b.dbProxy.addAsset(self.iap1)
        b.dbProxy.addAsset(self.iap2)
        b.dbProxy.addAsset(self.iap3)
        self.oap = b.dbProxy.getAssets()
        self.iThreats = d['threats']
        self.iteps = [
            ThreatEnvironmentProperties(
                self.iThreats[0]["theEnvironmentProperties"][0]["theName"],
                self.iThreats[0]["theEnvironmentProperties"][0]
                ["theLikelihood"],
                self.iThreats[0]["theEnvironmentProperties"][0]["theAssets"],
                self.iThreats[0]["theEnvironmentProperties"][0]
                ["theAttackers"], self.iThreats[0]["theEnvironmentProperties"]
                [0]["theProperties"][0][1], self.iThreats[0]
                ["theEnvironmentProperties"][0]["theProperties"][0][1])
        ]
        self.itps = ThreatParameters(self.iThreats[0]["theName"],
                                     self.iThreats[0]["theType"],
                                     self.iThreats[0]["theMethod"], [],
                                     self.iteps)
        b.dbProxy.addThreat(self.itps)
        self.otps = b.dbProxy.getThreats()
        self.iVuln = d['vulnerabilities']
        self.iveps = [
            VulnerabilityEnvironmentProperties(
                self.iVuln[0]["theEnvironmentProperties"][0]["theName"],
                self.iVuln[0]["theEnvironmentProperties"][0]["theSeverity"],
                self.iVuln[0]["theEnvironmentProperties"][0]["theAssets"])
        ]
        self.ivp = VulnerabilityParameters(self.iVuln[0]["theName"],
                                           self.iVuln[0]["theDescription"],
                                           self.iVuln[0]["theType"], [],
                                           self.iveps)
        b.dbProxy.addVulnerability(self.ivp)
        self.ovp = b.dbProxy.getVulnerabilities()
        self.imc = d['misuseCase']
        self.iRisks = d['risks']

        imcep = [
            MisuseCaseEnvironmentProperties(
                self.imc[0]["theEnvironmentProperties"][0]["theName"],
                self.imc[0]["theEnvironmentProperties"][0]["theDescription"])
        ]
        imcp = MisuseCase(int(0), self.imc[0]["theName"], imcep,
                          self.imc[0]["theRisk"])
        irp = RiskParameters(self.iRisks[0]["theName"],
                             self.iRisks[0]["threatName"],
                             self.iRisks[0]["vulName"], imcp, [])
        b.dbProxy.addRisk(irp)
        oRisks = b.dbProxy.getRisks()
        self.r = oRisks[self.iRisks[0]["theName"]]
        self.iResponses = d['responses']
        iar1Name = self.iResponses[0]["theType"] + " " + self.iResponses[0][
            "theRisk"]
        iaep1 = AcceptEnvironmentProperties(
            self.iResponses[0]["theEnvironmentProperties"][0],
            self.iResponses[0]["theEnvironmentProperties"][1],
            self.iResponses[0]["theEnvironmentProperties"][2])
        iar1 = ResponseParameters(iar1Name, self.iResponses[0]["theRisk"], [],
                                  [iaep1], self.iResponses[0]["theType"])

        iar2Name = self.iResponses[1]["theType"] + " " + self.iResponses[1][
            "theRisk"]
        iaep2 = MitigateEnvironmentProperties(
            self.iResponses[1]["theEnvironmentProperties"],
            self.iResponses[1]["theType"])
        iar2 = ResponseParameters(iar2Name, self.iResponses[1]["theRisk"], [],
                                  [iaep2], self.iResponses[1]["theType"])

        b.dbProxy.addResponse(iar1)
        b.dbProxy.addResponse(iar2)

        self.ors = b.dbProxy.getResponses()
        self.oar1 = self.ors[iar1Name]
        self.oar2 = self.ors[iar2Name]

        rgp = cairis.core.GoalFactory.build(self.oar2)
        riskParameters = rgp[0]
        riskGoalId = b.dbProxy.addGoal(riskParameters)
        b.dbProxy.addTrace('response_goal', self.oar2.id(), riskGoalId)
        if (rgp > 1):
            threatParameters = rgp[1]
            vulnerabilityParameters = rgp[2]
            b.dbProxy.addGoal(vulnerabilityParameters)
            b.dbProxy.addGoal(threatParameters)
        b.dbProxy.relabelGoals(iaep2.name())

        oGoals = b.dbProxy.getGoals()
        self.rg = oGoals['Deter' + self.oar2.risk()]
        self.vg = oGoals[vulnerabilityParameters.name()]
        self.tg = oGoals[threatParameters.name()]

        ogops = b.dbProxy.getGoalAssociations()
        self.ogop1 = ogops[iaep2.name() + '/' + riskParameters.name() + '/' +
                           threatParameters.name() + '/or']
        self.ogop2 = ogops[iaep2.name() + '/' + riskParameters.name() + '/' +
                           vulnerabilityParameters.name() + '/or']

        self.reqId = b.dbProxy.newId()
        self.irequirements = d['requirements']
        self.ireq = cairis.core.RequirementFactory.build(
            self.reqId, self.irequirements[0]["theLabel"],
            self.irequirements[0]["theName"],
            self.irequirements[0]["theDescription"],
            self.irequirements[0]["thePriority"],
            self.irequirements[0]["theRationale"],
            self.irequirements[0]["theFitCriterion"],
            self.irequirements[0]["theOriginator"],
            self.irequirements[0]["theType"],
            self.irequirements[0]["theReference"], 1)
        b.dbProxy.addRequirement(self.ireq,
                                 self.irequirements[0]["theReference"], True)
        oreqs = b.dbProxy.getRequirements()
        self.oreq = oreqs[self.ireq.description()]

        iga = GoalAssociationParameters(iaep2.name(),
                                        self.vg.name(), 'goal', 'and',
                                        self.oreq.name(), 'requirement', 0,
                                        'None')
        b.dbProxy.addGoalAssociation(iga)
        ogops = b.dbProxy.getGoalAssociations()
        self.ogop3 = ogops[iaep2.name() + '/' + self.vg.name() + '/' +
                           self.oreq.name() + '/and']

        self.iCountermeasures = d['countermeasures']
Exemplo n.º 24
0
    def setUp(self):
        call([os.environ['CAIRIS_SRC'] + "/test/initdb.sh"])
        cairis.core.BorgFactory.initialise()
        f = open(os.environ['CAIRIS_SRC'] + '/test/responses.json')
        d = json.load(f)
        f.close()
        self.ienvs = d['environments']
        self.iep1 = EnvironmentParameters(self.ienvs[0]["theName"],
                                          self.ienvs[0]["theShortCode"],
                                          self.ienvs[0]["theDescription"])
        b = Borg()
        b.dbProxy.addEnvironment(self.iep1)
        self.oenvs = b.dbProxy.getEnvironments()
        self.iRoles = d['roles']
        self.irp = RoleParameters(self.iRoles[0]["theName"],
                                  self.iRoles[0]["theType"],
                                  self.iRoles[0]["theShortCode"],
                                  self.iRoles[0]["theDescription"], [])
        b.dbProxy.addRole(self.irp)
        self.oRoles = b.dbProxy.getRoles()
        self.iPersonas = d['personas']
        self.ipp = PersonaParameters(
            self.iPersonas[0]["theName"], self.iPersonas[0]["theActivities"],
            self.iPersonas[0]["theAttitudes"],
            self.iPersonas[0]["theAptitudes"],
            self.iPersonas[0]["theMotivations"],
            self.iPersonas[0]["theSkills"], self.iPersonas[0]["theIntrinsic"],
            self.iPersonas[0]["theContextual"], "", "0",
            self.iPersonas[0]["thePersonaType"], [], [
                PersonaEnvironmentProperties(
                    self.iPersonas[0]["theEnvironmentProperties"][0]
                    ["theName"], (self.iPersonas[0]["theEnvironmentProperties"]
                                  [0]["theDirectFlag"] == "True"),
                    self.iPersonas[0]["theEnvironmentProperties"][0]
                    ["theNarrative"], self.iPersonas[0]
                    ["theEnvironmentProperties"][0]["theRole"])
            ], [])
        b.dbProxy.addPersona(self.ipp)
        self.opp = b.dbProxy.getPersonas()
        self.iExternalDocuments = d['external_documents']
        self.iec1 = ExternalDocumentParameters(
            self.iExternalDocuments[0]["theName"],
            self.iExternalDocuments[0]["theVersion"],
            self.iExternalDocuments[0]["thePublicationDate"],
            self.iExternalDocuments[0]["theAuthors"],
            self.iExternalDocuments[0]["theDescription"])
        self.iec2 = ExternalDocumentParameters(
            self.iExternalDocuments[1]["theName"],
            self.iExternalDocuments[1]["theVersion"],
            self.iExternalDocuments[1]["thePublicationDate"],
            self.iExternalDocuments[1]["theAuthors"],
            self.iExternalDocuments[1]["theDescription"])
        b.dbProxy.addExternalDocument(self.iec1)
        b.dbProxy.addExternalDocument(self.iec2)
        self.oecs = b.dbProxy.getExternalDocuments()
        self.iDocumentReferences = d['document_references']
        self.idr1 = DocumentReferenceParameters(
            self.iDocumentReferences[0]["theName"],
            self.iDocumentReferences[0]["theDocName"],
            self.iDocumentReferences[0]["theContributor"],
            self.iDocumentReferences[0]["theExcerpt"])
        self.idr2 = DocumentReferenceParameters(
            self.iDocumentReferences[1]["theName"],
            self.iDocumentReferences[1]["theDocName"],
            self.iDocumentReferences[1]["theContributor"],
            self.iDocumentReferences[1]["theExcerpt"])
        b.dbProxy.addDocumentReference(self.idr1)
        b.dbProxy.addDocumentReference(self.idr2)
        self.odrs = b.dbProxy.getDocumentReferences()
        self.iPersonaCharacteristics = d['persona_characteristics']
        self.ipc1 = PersonaCharacteristicParameters(
            self.iPersonaCharacteristics[0]["thePersonaName"],
            self.iPersonaCharacteristics[0]["theModQual"],
            self.iPersonaCharacteristics[0]["theVariable"],
            self.iPersonaCharacteristics[0]["theCharacteristic"],
            [(self.iPersonaCharacteristics[0]["ground"], '', 'document')],
            [(self.iPersonaCharacteristics[0]["warrant"], '', 'document')], [],
            [])
        b.dbProxy.addPersonaCharacteristic(self.ipc1)
        self.opcs = b.dbProxy.getPersonaCharacteristics()
        self.iAttackers = d['attackers']
        self.iatkeps = [
            AttackerEnvironmentProperties(
                self.iAttackers[0]["theEnvironmentProperties"][0]["theName"],
                self.iAttackers[0]["theEnvironmentProperties"][0]["theRoles"],
                self.iAttackers[0]["theEnvironmentProperties"][0]
                ["theMotives"], self.iAttackers[0]["theEnvironmentProperties"]
                [0]["theCapabilities"])
        ]
        self.iatk = AttackerParameters(self.iAttackers[0]["theName"],
                                       self.iAttackers[0]["theDescription"],
                                       self.iAttackers[0]["theImage"], [],
                                       self.iatkeps)
        b.dbProxy.addAttacker(self.iatk)
        self.oAttackers = b.dbProxy.getAttackers()
        self.iVtypes = d['valuetypes']
        self.ivt1 = ValueTypeParameters(self.iVtypes[0]["theName"],
                                        self.iVtypes[0]["theDescription"],
                                        self.iVtypes[0]["theType"])
        self.ivt2 = ValueTypeParameters(self.iVtypes[1]["theName"],
                                        self.iVtypes[1]["theDescription"],
                                        self.iVtypes[1]["theType"])
        b.dbProxy.addValueType(self.ivt1)
        b.dbProxy.addValueType(self.ivt2)
        self.ovtt = b.dbProxy.getValueTypes('threat_type')
        self.ovtv = b.dbProxy.getValueTypes('vulnerability_type')
        self.iassets = d['assets']
        self.iaeps1 = [
            AssetEnvironmentProperties(
                self.iassets[0]["theEnvironmentProperties"][0][0],
                self.iassets[0]["theEnvironmentProperties"][0][1],
                self.iassets[0]["theEnvironmentProperties"][0][2])
        ]
        self.iaeps2 = [
            AssetEnvironmentProperties(
                self.iassets[1]["theEnvironmentProperties"][0][0],
                self.iassets[1]["theEnvironmentProperties"][0][1],
                self.iassets[1]["theEnvironmentProperties"][0][2])
        ]
        self.iaeps3 = [
            AssetEnvironmentProperties(
                self.iassets[2]["theEnvironmentProperties"][0][0],
                self.iassets[2]["theEnvironmentProperties"][0][1],
                self.iassets[2]["theEnvironmentProperties"][0][2])
        ]
        self.iap1 = AssetParameters(self.iassets[0]["theName"],
                                    self.iassets[0]["theShortCode"],
                                    self.iassets[0]["theDescription"],
                                    self.iassets[0]["theSignificance"],
                                    self.iassets[0]["theType"], "0", "N/A", [],
                                    [], self.iaeps1)
        self.iap2 = AssetParameters(self.iassets[1]["theName"],
                                    self.iassets[1]["theShortCode"],
                                    self.iassets[1]["theDescription"],
                                    self.iassets[1]["theSignificance"],
                                    self.iassets[1]["theType"], "0", "N/A", [],
                                    [], self.iaeps2)
        self.iap3 = AssetParameters(self.iassets[2]["theName"],
                                    self.iassets[2]["theShortCode"],
                                    self.iassets[2]["theDescription"],
                                    self.iassets[2]["theSignificance"],
                                    self.iassets[2]["theType"], "0", "N/A", [],
                                    [], self.iaeps3)
        b.dbProxy.addAsset(self.iap1)
        b.dbProxy.addAsset(self.iap2)
        b.dbProxy.addAsset(self.iap3)
        self.oap = b.dbProxy.getAssets()
        self.iThreats = d['threats']
        self.iteps = [
            ThreatEnvironmentProperties(
                self.iThreats[0]["theEnvironmentProperties"][0]["theName"],
                self.iThreats[0]["theEnvironmentProperties"][0]
                ["theLikelihood"],
                self.iThreats[0]["theEnvironmentProperties"][0]["theAssets"],
                self.iThreats[0]["theEnvironmentProperties"][0]
                ["theAttackers"], self.iThreats[0]["theEnvironmentProperties"]
                [0]["theProperties"][0][1], self.iThreats[0]
                ["theEnvironmentProperties"][0]["theProperties"][0][1])
        ]
        self.itps = ThreatParameters(self.iThreats[0]["theName"],
                                     self.iThreats[0]["theType"],
                                     self.iThreats[0]["theMethod"], [],
                                     self.iteps)
        b.dbProxy.addThreat(self.itps)
        self.otps = b.dbProxy.getThreats()
        self.iVuln = d['vulnerabilities']
        self.iveps = [
            VulnerabilityEnvironmentProperties(
                self.iVuln[0]["theEnvironmentProperties"][0]["theName"],
                self.iVuln[0]["theEnvironmentProperties"][0]["theSeverity"],
                self.iVuln[0]["theEnvironmentProperties"][0]["theAssets"])
        ]
        self.ivp = VulnerabilityParameters(self.iVuln[0]["theName"],
                                           self.iVuln[0]["theDescription"],
                                           self.iVuln[0]["theType"], [],
                                           self.iveps)
        b.dbProxy.addVulnerability(self.ivp)
        self.ovp = b.dbProxy.getVulnerabilities()
        self.imc = d['misuseCase']
        self.iRisks = d['risks']

        imcep = [
            MisuseCaseEnvironmentProperties(
                self.imc[0]["theEnvironmentProperties"][0]["theName"],
                self.imc[0]["theEnvironmentProperties"][0]["theDescription"])
        ]
        imcp = MisuseCase(int(0), self.imc[0]["theName"], imcep,
                          self.imc[0]["theRisk"])
        irp = RiskParameters(self.iRisks[0]["theName"],
                             self.iRisks[0]["threatName"],
                             self.iRisks[0]["vulName"], imcp, [])
        b.dbProxy.addRisk(irp)
        oRisks = b.dbProxy.getRisks()
        self.r = oRisks[self.iRisks[0]["theName"]]
        self.iResponses = d['responses']
 def setUp(self):
     call([os.environ['CAIRIS_CFG_DIR'] + "/initdb.sh"])
     cairis.core.BorgFactory.initialise()
     b = Borg()
     b.dbProxy.addEnvironment(
         EnvironmentParameters('Default', 'DEFAULT', 'Default Environment'))