WsfCyberAttack.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 WSFCYBERATTACK_HPP
#define WSFCYBERATTACK_HPP
 
#include "wsf_cyber_export.h"
 
#include <memory>
#include <string>
#include <vector>
 
#include "WsfObject.hpp"
#include "WsfRandomVariable.hpp"
class WsfSimulation;
 
namespace wsf
{
namespace cyber
{
class Engagement;
 
namespace random
{
enum ProbabilityFrequency
{
   cALWAYS,
   cONCE_PER_SIMULATION,
   cONCE_PER_TARGET,
   cINTERVAL_PER_SIMULATION,
   cINTERVAL_PER_TARGET,
   cOTHER
};
} // namespace random

class WSF_CYBER_EXPORT Attack : public WsfObject
{
public:
   Attack()                   = default;
   ~Attack() override         = default;
   Attack(const Attack& aSrc) = default;
   Attack& operator=(const Attack& aRhs) = default;


   Attack* Clone() const override;
   bool    ProcessInput(UtInput& aInput) override;
 
   virtual bool Initialize(double aSimTime, WsfSimulation& aSimulation);


   double GetProbabilityOfScanDetection() const { return mProbabilityOfScanDetection; }
   double GetProbabilityOfScanAttribution() const { return mProbabilityOfScanAttribution; }
   double GetProbabilityOfAttackSuccess() const { return mProbabilityOfAttackSuccess; }
   double GetProbabilityOfStatusReport() const { return mProbabilityOfStatusReport; }
   double GetProbabilityOfAttackDetection() const { return mProbabilityOfAttackDetection; }
   double GetProbabilityOfAttackAttribution() const { return mProbabilityOfAttackAttribution; }
   double GetProbabilityOfFutureImmunity() const { return mProbabilityOfFutureImmunity; }


   random::ProbabilityFrequency GetFrequencyOfScanDetection() const { return mFrequencyOfScanDetection; }
   random::ProbabilityFrequency GetFrequencyOfScanAttribution() const { return mFrequencyOfScanAttribution; }
   random::ProbabilityFrequency GetFrequencyOfAttackSuccess() const { return mFrequencyOfAttackSuccess; }
   random::ProbabilityFrequency GetFrequencyOfStatusReport() const { return mFrequencyOfStatusReport; }
   random::ProbabilityFrequency GetFrequencyOfAttackDetection() const { return mFrequencyOfAttackDetection; }
   random::ProbabilityFrequency GetFrequencyOfAttackAttribution() const { return mFrequencyOfAttackAttribution; }
   random::ProbabilityFrequency GetFrequencyOfFutureImmunity() const { return mFrequencyOfFutureImmunity; }


   WsfRandomVariable& GetRandomVariableScanDetection() { return mRandomVariableScanDetection; }
   WsfRandomVariable& GetRandomVariableScanAttribution() { return mRandomVariableScanAttribution; }
   WsfRandomVariable& GetRandomVariableAttackSuccess() { return mRandomVariableAttackSuccess; }
   WsfRandomVariable& GetRandomVariableStatusReport() { return mRandomVariableStatusReport; }
   WsfRandomVariable& GetRandomVariableAttackDetection() { return mRandomVariableAttackDetection; }
   WsfRandomVariable& GetRandomVariableAttackAttribution() { return mRandomVariableAttackAttribution; }
   WsfRandomVariable& GetRandomVariableFutureImmunity() { return mRandomVariableFutureImmunity; }


   double GetDuration() const { return mDuration; }


   double GetTimeDelayScan() const { return mTimeDelayScan.Draw(); }
   double GetTimeDelayDelivery() const { return mTimeDelayDelivery.Draw(); }


   double GetLastTimeDelayScan() const { return mTimeDelayScan; }
   double GetLastTimeDelayDelivery() const { return mTimeDelayDelivery; }

   const std::vector<std::string>& GetEffects() const { return mEffectTypes; }

   double GetResourceRequirements() const { return mResourcesRequired; }

   virtual double ExtendedDrawDefinition(const std::string& aTarget = {});
 
protected:
   virtual void ProcessFrequencyInput(WsfRandomVariable&            aRandomVariable,
                                      random::ProbabilityFrequency& aFrequency,
                                      UtInput&                      aInput);
 
private:

   double mProbabilityOfScanDetection{0.0};
   double mProbabilityOfScanAttribution{0.0};
   double mProbabilityOfAttackSuccess{1.0};
   double mProbabilityOfStatusReport{1.0};
   double mProbabilityOfAttackDetection{0.0};
   double mProbabilityOfAttackAttribution{0.0};
   double mProbabilityOfFutureImmunity{0.0};

   double mDuration{0.0};

   double mResourcesRequired{0.0};


   mutable WsfRandomVariable mTimeDelayScan{WsfRandomVariable::cCONSTANT, 0.0, 0.0, WsfRandomVariable::cNON_NEGATIVE};
   mutable WsfRandomVariable mTimeDelayDelivery{WsfRandomVariable::cCONSTANT, 0.0, 0.0, WsfRandomVariable::cNON_NEGATIVE};


   random::ProbabilityFrequency mFrequencyOfScanDetection{random::cALWAYS};
   random::ProbabilityFrequency mFrequencyOfScanAttribution{random::cALWAYS};
   random::ProbabilityFrequency mFrequencyOfAttackSuccess{random::cALWAYS};
   random::ProbabilityFrequency mFrequencyOfStatusReport{random::cALWAYS};
   random::ProbabilityFrequency mFrequencyOfAttackDetection{random::cALWAYS};
   random::ProbabilityFrequency mFrequencyOfAttackAttribution{random::cALWAYS};
   random::ProbabilityFrequency mFrequencyOfFutureImmunity{random::cALWAYS};


   mutable WsfRandomVariable mRandomVariableScanDetection{};
   mutable WsfRandomVariable mRandomVariableScanAttribution{};
   mutable WsfRandomVariable mRandomVariableAttackSuccess{};
   mutable WsfRandomVariable mRandomVariableStatusReport{};
   mutable WsfRandomVariable mRandomVariableAttackDetection{};
   mutable WsfRandomVariable mRandomVariableAttackAttribution{};
   mutable WsfRandomVariable mRandomVariableFutureImmunity{};

   std::vector<std::string> mEffectTypes;
};
 
} // namespace cyber
} // namespace wsf
 
#endif