WsfCyberProtect.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2016 Infoscitex, a DCS Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef WSFCYBERPROTECT_HPP
#define WSFCYBERPROTECT_HPP
 
#include "wsf_cyber_export.h"
 
#include <list>
 
#include "UtMath.hpp"
class UtScript;
#include "UtScriptContext.hpp"
#include "WsfCyberComponentRoles.hpp"
#include "WsfObject.hpp"
class WsfPlatform;
#include "WsfRandomVariable.hpp"
class WsfScenario;
#include "WsfSimpleComponent.hpp"
#include "script/WsfScriptContext.hpp"
 
namespace wsf
{
namespace cyber
{
class Engagement;

class WSF_CYBER_EXPORT Protect : public WsfObject, public WsfSimplePlatformComponent
{
public:
   static Protect* Find(const WsfPlatform& aPlatform);
   static void     RegisterComponentFactory(WsfScenario& aScenario);
 
   Protect(WsfScenario& aScenario);
   ~Protect() override = default;

   Protect& operator=(const Protect& aRhs) = delete;


   WsfComponent* CloneComponent() const override { return Clone(); }
   void*         QueryInterface(int aRole) override { return (aRole == mRoles[0]) ? this : nullptr; }
   void          ComponentParentChanged(WsfPlatform* aPlatformPtr) override { mPlatformPtr = aPlatformPtr; }


   Protect* Clone() const override;
   bool     Initialize(double aSimTime) override;
   bool     ProcessInput(UtInput& aInput) override;

   bool DefaultExists() const { return mDefaultDefined; }

   bool ProtectionExists(const std::string& aAttackName) const;


   double GetProbabilityOfScanDetection(const std::string& aAttackName) const;
   double GetProbabilityOfScanAttribution(const std::string& aAttackName) const;
   double GetProbabilityOfAttackSuccess(const std::string& aAttackName) const;
   double GetProbabilityOfStatusReport(const std::string& aAttackName) const;
   double GetProbabilityOfAttackDetection(const std::string& aAttackName) const;
   double GetProbabilityOfAttackAttribution(const std::string& aAttackName) const;
   double GetProbabilityOfFutureImmunity(const std::string& aAttackName) const;
   double DetectionDelayTime(const std::string& aAttackName) const;
   double RecoveryDelayTime(const std::string& aAttackName) const;
   double LastDetectionDelayTime(const std::string& aAttackName) const;
   double LastRecoveryDelayTime(const std::string& aAttackName) const;
   bool   DoRestore(const std::string& aAttackName) const;
   bool   IsImmune(const std::string& aAttackName) const;


   void ExecuteOnAttackDetection(Engagement& aEngagement, double aSimTime);
   void ExecuteOnAttackRecovery(Engagement& aEngagement, double aSimTime);
   void ExecuteOnScanDetection(Engagement& aEngagement, double aSimTime);
   bool ExecuteIsVulnerable(Engagement& aEngagement, double aSimTime, bool& aWasRun);

   void SetImmune(const std::string& aNamedAttack) { mImmuneAttacks.push_back(aNamedAttack); }
 
   WsfScriptContext& GetScriptContext() { return mContext; }
   UtScriptContext*  GetScriptAccessibleContext() const override { return &mContext.GetContext(); }
 
protected:
   Protect(const Protect& aSrc);

   class ProtectedAttack : public WsfNamed
   {
   public:
      ~ProtectedAttack() override = default;
 
      bool ProcessInput(UtInput& aInput, WsfScriptContext& aContext);

      double mScanDetection{0.0};
      double mScanAttribution{0.0};
      double mAttackSuccess{1.0};
      double mStatusReport{0.0};
      double mAttackDetection{0.0};
      double mAttackAttribution{0.0};
      double mImmunity{0.0};
 
      mutable WsfRandomVariable mDetectionDelay{WsfRandomVariable::cCONSTANT, 0, 0, WsfRandomVariable::cNON_NEGATIVE};
      mutable WsfRandomVariable mRecoveryDelay{WsfRandomVariable::cCONSTANT, 0, 0, WsfRandomVariable::cNON_NEGATIVE};
 
      bool mRestore{false};
 
      UtScript* mOnAttackDetection{nullptr};
      UtScript* mOnAttackRecovery{nullptr};
      UtScript* mOnScanDetection{nullptr};
      UtScript* mIsVulnerable{nullptr};
   };


   using ProtectedAttackList           = std::vector<ProtectedAttack>;
   using ProtectedAttackListIt         = std::vector<ProtectedAttack>::const_iterator;
   using ProtectedAttackListNonConstIt = std::vector<ProtectedAttack>::iterator;
 
private:
   ProtectedAttackListIt         FindAttackProtection(const std::string& aAttackName) const;
   ProtectedAttackListNonConstIt FindAttackProtection(const std::string& aAttackName);

   WsfScenario* mScenarioPtr;

   WsfPlatform* mPlatformPtr;

   ProtectedAttackList mNamedAttacks;

   bool mDefaultDefined;

   std::vector<std::string> mImmuneAttacks;
 
   WsfScriptContext mContext;
   UtScriptClass*   mEngagementClassPtr; // = mContext.GetClass("WsfCyberEngagement");
};
 
} // namespace cyber
} // namespace wsf
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(wsf::cyber::Protect, cWSF_COMPONENT_CYBER_PROTECT)
 
#endif