WsfCyberEngagement.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 WSFCYBERENGAGEMENT_HPP
#define WSFCYBERENGAGEMENT_HPP
 
#include "wsf_cyber_export.h"
 
#include <limits>
 
#include "UtCloneablePtr.hpp"
#include "UtScriptAccessible.hpp"
#include "UtScriptBasicTypes.hpp"
#include "UtScriptClass.hpp"
#include "WsfCyberRandom.hpp"
class WsfPlatform;
class WsfSimulation;
 
namespace wsf
{
namespace cyber
{
class Attack;
class Protect;
class Constraint;

class WSF_CYBER_EXPORT Engagement : public UtScriptAccessible
{
public:
   enum CyberAttackFailure
   {
      cATTACK_RANDOM_DRAW,
      cATTACK_IMMUNITY,
      cATTACK_NOT_VULNERABLE,
      cATTACK_INSUFFICIENT_RESOURCES,
      cATTACK_NONE
   };
 
   enum CyberScanFailure
   {
      cSCAN_IMMUNITY,
      cSCAN_DETECTED,
      cSCAN_NOT_VULNERABLE,
      cSCAN_NONE
   };

   Engagement(std::string    aAttackingPlatform,
              std::string    aVictimPlatform,
              std::string    aNamedAttack,
              WsfSimulation& aSimulation,
              size_t         aKey);
 
   virtual ~Engagement();
 
   Engagement(const Engagement& aSrc) = delete;
   Engagement(Engagement&& aSrc)      = default;
   const Engagement& operator=(const Engagement& aRhs) = delete;
 
   const char* GetScriptClassName() const override { return "WsfCyberEngagement"; }


   const std::string& GetAttacker() const { return mAttacker; }
   size_t             GetAttackerIndex() const { return mAttackerIndex; }
   const std::string& GetVictim() const { return mVictim; }
   size_t             GetVictimIndex() const { return mVictimIndex; }
   const std::string& GetAttackType() const { return mNamedAttack; }
   size_t             GetKey() const { return mKey; }
 
   Attack* GetAttack() const { return mAttackPtr; }
   double  GetDuration() const { return mDuration; }
   double  GetAttackStartTime() const { return mTimeAttackStart; }
   double  GetAttackSuccessThreshold() const { return mAttackSuccessThreshold; }
   double  GetAttackDraw() const { return mAttackDraw; }
   double  GetStatusReportThreshold() const { return mStatusReportThreshold; }
   double  GetStatusReportDraw() const { return mStatusReportDraw; }

   bool                            GetStatusReportSuccess() const;
   double                          GetTimeAttackDiscovered() const { return mTimeAttackDetection; }
   double                          GetAttackDetectionThreshold() const { return mAttackDetectionThreshold; }
   double                          GetAttackDetectionDraw() const { return mAttackDetectionDraw; }
   double                          GetAttackAttributionThreshold() const { return mAttackAttributionThreshold; }
   double                          GetAttackAttributionDraw() const { return mAttackAttributionDraw; }
   double                          GetTimeAttackRecovery() const { return mTimeAttackRecovery; }
   bool                            GetRecovery() const { return mRecover; }
   double                          GetScanStartTime() const { return mTimeScanStart; }
   double                          GetScanDetectionThreshold() const { return mScanDetectionThreshold; }
   double                          GetScanDetectionDraw() const { return mScanDetectionDraw; }
   double                          GetScanAttributionThreshold() const { return mScanAttributionThreshold; }
   double                          GetScanAttributionDraw() const { return mScanAttributionDraw; }
   double                          GetScanDelayTime() const { return mTimeScanDelay; }
   double                          GetDeliveryDelayTime() const { return mTimeDeliveryDelay; }
   bool                            GetScanSuccess() const { return mScanSuccess; }
   bool                            GetAttackInProgress() const { return mAttackInProgress; }
   bool                            GetAttackSuccess() const { return mAttackSuccess; }
   const std::vector<std::string>& GetAttackEffects() const { return mAttackEffectTypes; }
   double                          GetAttackDetectionDelayTime() const { return mTimeAttackDetectionDelay; }
   double                          GetAttackRecoveryDelayTime() const { return mTimeAttackRecoveryDelay; }
   double                          GetImmunityThreshold() const { return mImmunityThreshold; }
   double                          GetImmunityDraw() const { return mImmunityDraw; }

   Protect* GetUsedProtection() { return mProtectTypePtr; }


   CyberAttackFailure GetAttackFailureReason() const { return mAttackFailure; }
   CyberScanFailure   GetScanFailureReason() const { return mScanFailure; }


   void SetAttackFailureReason(CyberAttackFailure aAttackFailure) { mAttackFailure = aAttackFailure; }
   void SetScanFailureReason(CyberScanFailure aScanFailure) { mScanFailure = aScanFailure; }


   void SetAttackStartTime();
   void SetScanStartTime();
   void SetTimeAttackDiscovered();
   void SetTimeAttackRecovery();
 
   void SetScanSuccess(bool aSuccess) { mScanSuccess = aSuccess; }
   void SetAttackInProgress(bool aInProgress) { mAttackInProgress = aInProgress; }
   void SetAttackSuccess(bool aSuccess) { mAttackSuccess = aSuccess; }

   bool IsVictimImmune() const;

   bool Draw(random::ProbabilityType aProbabilityType);

   virtual void Reset(bool aScanReset = false);

   void ReleaseAttackerConstraints();

   bool MeetsAttackerConstraints();

   bool MakeConstraintReservations();

   bool ExistingConstraintReservations();
 
   WsfSimulation& GetSimulation() const { return mSimulation; }
 
private:
   void SetDefiningCyberObject();

   void SetInitialValues();
 
   std::string mAttacker{};
   size_t      mAttackerIndex{0U};
   std::string mVictim{};
   size_t      mVictimIndex{0U};
   std::string mNamedAttack{};
   size_t      mKey{0U};

   double             mTimeAttackStart{std::numeric_limits<double>::max()};
   double             mDuration{-1.0};
   double             mAttackSuccessThreshold{1.0};
   double             mAttackDraw{-1.0};
   double             mCyberResourceUsage{0.0};
   double             mStatusReportThreshold{1.0};
   double             mStatusReportDraw{-1.0};
   double             mTimeAttackDetection{-1.0};
   double             mTimeAttackDetectionDelay{std::numeric_limits<double>::max()};
   double             mAttackDetectionThreshold{0.0};
   double             mAttackDetectionDraw{-1.0};
   double             mAttackAttributionThreshold{0.0};
   double             mAttackAttributionDraw{-1.0};
   double             mTimeAttackRecovery{-1.0};
   double             mTimeAttackRecoveryDelay{std::numeric_limits<double>::max()};
   bool               mRecover{false};
   CyberAttackFailure mAttackFailure{cATTACK_NONE};
   double             mTimeDeliveryDelay{0.0};
   bool               mAttackInProgress{false};
   bool               mAttackSuccess{false};

   double           mTimeScanStart{std::numeric_limits<double>::max()};
   double           mScanDetectionThreshold{0.0};
   double           mScanDetectionDraw{-1.0};
   double           mScanAttributionThreshold{0.0};
   double           mScanAttributionDraw{-1.0};
   CyberScanFailure mScanFailure{cSCAN_NONE};
   double           mTimeScanDelay{0.0};
   bool             mScanSuccess{false};

   double mImmunityThreshold{0.0};
   double mImmunityDraw{-1.0};
 
   bool mUseProtectDefinition{false};
 
   WsfSimulation&           mSimulation;
   Protect*                 mProtectTypePtr{nullptr};
   Constraint*              mConstraintPtr{nullptr};
   std::vector<std::string> mAttackEffectTypes{};

   UtCloneablePtr<Attack> mAttackPtr{nullptr};
};
 

class WSF_CYBER_EXPORT ScriptEngagement : public UtScriptClass
{
public:
   ScriptEngagement(const std::string& aClassName, UtScriptTypes* aScriptTypesPtr);
 


   UT_DECLARE_SCRIPT_METHOD(Attacker);
   UT_DECLARE_SCRIPT_METHOD(AttackerPlatform);
   UT_DECLARE_SCRIPT_METHOD(AttackType);
   UT_DECLARE_SCRIPT_METHOD(Victim);
   UT_DECLARE_SCRIPT_METHOD(VictimPlatform);


   UT_DECLARE_SCRIPT_METHOD(TimeAttackInitiated);
   UT_DECLARE_SCRIPT_METHOD(AttackSuccessThreshold);
   UT_DECLARE_SCRIPT_METHOD(AttackSuccessDraw);
   UT_DECLARE_SCRIPT_METHOD(StatusReportThreshold);
   UT_DECLARE_SCRIPT_METHOD(StatusReportDraw);
   UT_DECLARE_SCRIPT_METHOD(TimeAttackDiscovered);
   UT_DECLARE_SCRIPT_METHOD(AttackDetectionThreshold);
   UT_DECLARE_SCRIPT_METHOD(AttackDetectionDraw);
   UT_DECLARE_SCRIPT_METHOD(AttackAttributionThreshold);
   UT_DECLARE_SCRIPT_METHOD(AttackAttributionDraw);
   UT_DECLARE_SCRIPT_METHOD(TimeAttackRecovery);
   UT_DECLARE_SCRIPT_METHOD(Recovery);
   UT_DECLARE_SCRIPT_METHOD(AttackDeliveryDelayTime);
   UT_DECLARE_SCRIPT_METHOD(AttackDetectionDelayTime);
   UT_DECLARE_SCRIPT_METHOD(AttackRecoveryDelayTime);
   UT_DECLARE_SCRIPT_METHOD(AttackSuccess);
   UT_DECLARE_SCRIPT_METHOD(AttackInProgress);
   UT_DECLARE_SCRIPT_METHOD(AttackFailureReason);


   UT_DECLARE_SCRIPT_METHOD(TimeScanInitiated);
   UT_DECLARE_SCRIPT_METHOD(ScanDetectionThreshold);
   UT_DECLARE_SCRIPT_METHOD(ScanDetectionDraw);
   UT_DECLARE_SCRIPT_METHOD(ScanAttributionThreshold);
   UT_DECLARE_SCRIPT_METHOD(ScanAttributionDraw);
   UT_DECLARE_SCRIPT_METHOD(ScanDelayTime);
   UT_DECLARE_SCRIPT_METHOD(ScanSuccess);
   UT_DECLARE_SCRIPT_METHOD(ScanInProgress);
   UT_DECLARE_SCRIPT_METHOD(ScanFailureReason);
};
 
} // namespace cyber
 
} // namespace wsf
 
#endif