PHP Decode

 b'

namespace app\components;

use app\models\System;
use DateInterval;
use DateTime;
use Exception;
use LicenseLog;
use ReflectionClass;
use SystemCounter;
use User;
use Yii;

/**
 * License
 *
 * @test LicenseTest
 */
class License {
    use CacheTrait;

    /**
     * Constants
     */
    public const TYPE_DEMO = "demo";
    public const TYPE_COMMERCIAL = "commercial";

    public const LIMIT_RECIPIENTS = "recipients";

    # Schedule
    public const OPTION_SCHEDULE = "schedule";
    public const OPTION_SCHEDULE_RANDOMIZATION = "schedule_randomization";

    # Reports
    public const OPTION_REPORTS = "reports";
    public const OPTION_ADVANCED_REPORTS = "advanced_reports";
    public const OPTION_BOUNCE_OOO_REPORTING = "bounce_and_ooo_reporting";

    # Endusers, clients and recipients
    public const OPTION_CLIENT_VIEW_ACCOUNTS = "client_view_accounts";
    public const OPTION_RECIPIENT_REPUTATION = "recipient_reputation";
    public const OPTION_RECIPIENT_HISTORY = "recipient_history";
    public const OPTION_ACCESS_CONTROL = "role_based_access_control";
    public const OPTION_USER_GROUPS = "multi_layred_user_groups"; // @noRelations @todo after PHISH-4015

    # Settings
    public const OPTION_WHITELABEL = "whitelabel";
    public const OPTION_LDAP_SYNC = "ldap_sync";
    public const OPTION_DMZ_MODE = "dmz_mode";
    public const OPTION_API = "api";
    public const OPTION_LDAP_API = "ldap_api"; // @noRelations @todo after PHISH-4015
    public const OPTION_SAML_SSO = "saml_sso"; // @noRelations @todo after PHISH-4015
    public const OPTION_DOMAIN_API = "domain_api";
    public const OPTION_2FA = "2fa";
    public const OPTION_HOMEPAGE_CREATION = "custom_homepage_creation";
    public const OPTION_URL_SHORTENING = "url_shortening";
    public const OPTION_BENCHMARK = "benchmark";
    public const OPTION_VIDEO_TRACKING = "advanced_video_tracking"; // @noRelations @todo after PHISH-4015
    public const OPTION_QUIZ_TRACKING = "advanced_quiz_tracking";
    public const OPTION_LANDING_PAGE_TIME_TRACKING = "landing_page_time_tracking";
    public const OPTION_REALTIME_DASHBOARD = "realtime_dashboard"; // @noRelations @todo after PHISH-4015
    public const OPTION_ANONYMIZATION = "anonymization_and_data_protection"; // @noRelations @todo after PHISH-4015
    public const OPTION_REMINDERS = "reminders";
    public const OPTION_ADMIN_INTERFACE = "multi_language_admin_interface"; // @noRelations @todo after PHISH-4015
    public const OPTION_RULE_BASED_ANALYSIS = "custom_rule_based_analysis"; // @noRelations @todo after PHISH-4015
    public const OPTION_MOBILE_RESPONSIVE = "mobile_responsive"; // @noRelations @todo after PHISH-4015

    # incidents
    public const OPTION_INCIDENT_HANDLING = "incident_handling";
    public const OPTION_INCIDENT_FEEDBACK = "incident_feedback";
    public const OPTION_INCIDENT_CLIENT = "incident_client";
    public const OPTION_DEEP_INSPECTION = "deep_inspection_request"; // @noRelations @todo after PHISH-4015

    # training and attacks
    public const OPTION_TRAINING_DIPLOMA = "training_diploma";
    public const OPTION_ENDUSERS = "training_portal";
    public const OPTION_DOUBLE_BARREL_ATTACKS = "double_barrel_attacks";
    public const OPTION_MIXED_ATTACKS = "mixed_attacks";
    public const OPTION_MEDIA_ATTACKS = "media_attacks";
    public const OPTION_SMISHING_ATTACKS = "smishing_attacks";
    public const OPTION_CUSTOM_MESSAGE_BIRD_ACCOUNT = "custom_message_bird_account";
    public const OPTION_JAVA_DROPPER = "java_dropper";
    public const OPTION_MALWARE_SIMULATION = "malware_simulation";
    public const OPTION_FILE_ATTACKS = "file_attacks";
    public const OPTION_PENTEST_KIT = "pentest_kit"; // @noRelations @todo after PHISH-4015
    public const OPTION_EXECUTABLE_PDF = "executable_pdf";
    public const OPTION_MAIL_WEB_FILTER_TEST = "mail_web_filter_test";
    public const OPTION_URL_ATTACK = "attack_url_variations"; // @noRelations @todo after PHISH-4015
    public const OPTION_ENTRY_ATTACK = "data_entry_attacks"; // @noRelations @todo after PHISH-4015
    public const OPTION_HYPERLINK_ATTACKS = "hyperlink_attacks"; // @noRelations @todo after PHISH-4015
    public const OPTION_LEVEL_BASED_ATTACKS = "level_based_attacks"; // @noRelations @todo after PHISH-4015
    public const OPTION_RANSOMWARE_SIMULATION = "ransomware_simulation"; // @noRelations @todo after PHISH-4015
    public const OPTION_TRAINING_SIMULATION = "phishing_training_simulation"; // @noRelations @todo after PHISH-4015
    public const OPTION_SPEAR_SIMULATION = "spear_phishing_simulation"; // @noRelations @todo after PHISH-4015
    public const OPTION_ATTACK_SIMULATION_INTEGRATION = "integration_with_attack_simulations"; // @noRelations @todo after PHISH-4015
    public const OPTION_SPOOFING_TEST = "spoofing_test";
    public const OPTION_IDENTITY_ATTACKS = "identity_attacks"; // @noRelations @todo after PHISH-4015

    # Awareness
    public const OPTION_AWARENESS_WEBSITE = "awareness_website";
    public const OPTION_SCORM_EXPORT = "scorm_export";
    public const OPTION_AUTHORING_TOOLKIT = "authoring_toolkit";
    public const OPTION_APPROVAL_WORKFLOWS = "approval_workflows";
    public const OPTION_REPUTATION_BASED_LEARNING = "reputation_based_learning";
    public const OPTION_DYNAMIC_TRAINING_HINTS = "dynamic_training_hints"; // @noRelations @todo after PHISH-4015

    # System & Session
    public const OPTION_EXPORT = "export";
    public const OPTION_INTERACTIVE_SESSION = "interactive_session";
    public const OPTION_ADVANCED_AUTHENTICATION = "advanced_authentication";
    public const OPTION_SSL_CERTS = "ssl_certificates";
    public const OPTION_CERT_AUTHENTICATION = "certificate_based_authentication"; // @noRelations @todo after PHISH-4015
    public const OPTION_MULTI_TENANT = "multi_tenant_view_only_access"; // @noRelations @todo after PHISH-4015

    # Threat
    public const OPTION_THREAT_ANALYSIS = "threat_analysis";
    public const OPTION_THREAT_MITIGATION = "threat_mitigation";
    public const OPTION_ACTIVE_DETECTION = "active_detection";
    public const OPTION_EMAIL_SPIDER = "email_spider";

    # Campaigns
    public const OPTION_DEFAULT_CAMPAIGN_TEMPLATES = "default_campaign_templates";
    public const OPTION_CAMPAIGN_CHECKS = "campaign_checks";
    public const OPTION_CAMPAIGN_COMPARISON = "campaign_comparison";
    public const OPTION_PERFORMANCE_CALCULATOR = "performance_calculator";

    # Mails
    public const OPTION_DIGITAL_SIGNATURES = "digital_signatures";
    public const OPTION_SUPPORT_PROXY = "support_proxy";
    public const OPTION_DKIM_MIME = "dkim_mime_for_emails";
    public const OPTION_MAIL_COMMUNICATION = "full_mail_communication_client";

    # Tools
    public const OPTION_WEBSITE_CLONER = "website_cloner";
    public const OPTION_ENTRY_TOOLKIT = "data_entry_validation_toolkit"; // @noRelations @todo after PHISH-4015
    public const OPTION_URL_REDIRECTION = "url_redirection_toolkit"; // @noRelations @todo after PHISH-4015
    public const OPTION_MALWARE_TOOLKIT = "malware_testing_toolkit"; // @noRelations @todo after PHISH-4015

    # Libraries
    public const OPTION_BASIC_ATTACK_TEMPLATES = "basic_attack_templates"; // @noRelations @todo after PHISH-4015
    public const OPTION_EXTENDED_ATTACK_TEMPLATES = "extended_attack_template_library"; // @noRelations @todo after PHISH-4015
    public const OPTION_FULL_ATTACT_TEMPLATES = "full_attack_template_library"; // @noRelations @todo after PHISH-4015
    public const OPTION_ATTACK_TEMPLATE_LIBRARY = "attack_template_library"; // @noRelations @todo after PHISH-4015
    public const OPTION_TRAINING_LIBRATY = "training_library"; // @noRelations @todo after PHISH-4015
    public const OPTION_BASIC_EDUCATION_LIBRARY = "basic_education_template_library"; // @noRelations @todo after PHISH-4015
    public const OPTION_EXTENDED_EDUCATION_LIBRARY = "extended_education_template_library"; // @noRelations @todo after PHISH-4015
    public const OPTION_FULL_EDUCATION_LIBRARY = "full_education_template_library"; // @noRelations @todo after PHISH-4015
    public const OPTION_MICROLEARNING_MODULE = "microlearning_modules"; // @noRelations @todo after PHISH-4015

    # Misc.
    public const OPTION_SUPPROT_STANDART = "support_standart";
    public const OPTION_SUPPORT_BUSINESS = "support_business";
    public const OPTION_SUPPORT_PREMIUM = "support_premium";
    public const OPTION_VPS_PROFESSIONAL = "vps_professional";
    public const OPTION_VPS_PREMIUM = "vps_premium";
    public const OPTION_VPS_ULTRA = "vps_ultra";

    # Templates
    public const OPTION_SECTOR_TEMPLATES = "sector_specific_templates"; // @noRelations @todo after PHISH-4015
    public const OPTION_TEMPLATE_CREATION = "custom_template_creation"; // @noRelations @todo after PHISH-4015

    # Plugins
    public const OPTION_GMAIL = "gmail";
    public const OPTION_OUTLOOK = "outlook";
    public const OPTION_OUTLOOK365 = "outlook365";
    public const OPTION_PLUGIN_CUSTOMIZATION = "plugin_customization_options"; // @noRelations @todo after PHISH-4015
    public const OPTION_CLIENT_COMPATIBLE = "multi_client_compatible"; // @noRelations @todo after PHISH-4015

    # Services
    public const OPTION_VIDEO_CUSTOMIZATOR = "video_customizator"; // @noRelations @todo after PHISH-4015
    public const OPTION_VIDEO_IMPORT_EXPORT = "video_import_export"; // @noRelations @todo after PHISH-4015
    public const OPTION_OFFLINE_SUPPORT = "offline_training_support";
    public const OPTION_EASY_INSTALLATION = "easy_installation";
    public const OPTION_SETUP_WIZARD = "setup_wizard";
    public const OPTION_INSTALLATION_SUPPORT = "installation_support";
    public const OPTION_VIDEO_CREATION = "custom_video_creation"; // @noRelations @todo after PHISH-4015
    public const OPTION_STATIC_TRAINING = "static_training_support"; // @noRelations @todo after PHISH-4015
    public const OPTION_CONSULTING_SERVICE = "consulting_service_subscription"; // @noRelations @todo after PHISH-4015
    public const OPTION_BUSINESS_INTELLIGENCE = "business_intelligence"; // @noRelations @todo after PHISH-4015
    public const OPTION_THIRD_PARTY_INTEGRATION = "third_party_integrations"; // @noRelations @todo after PHISH-4015
    public const OPTION_BEHAVIOR_REINFORCEMENT = "positive_behavior_reinforcement"; // @noRelations @todo after PHISH-4015

    # Expires in
    public const EXPIRES_IN_DEFAULT = "PT0S";
    public const EXPIRES_IN_TWO_WEEKS = "P2W";

    /**
     * @var string type
     */
    public $type = self::TYPE_DEMO;

    /**
     * @var int priority
     */
    public $priority = 0;

    /**
     * @var DateTime expire date
     */
    public $expiresAt;

    /**
     * @var int supportHours
     */
    public $supportHours;

    /**
     * @var array limits
     */
    private $_limits;

    /**
     * @var string workstationId
     */
    private $_workstationId;

    /**
     * @var string workstationKey
     */
    private $_workstationKey;

    /**
     * @var mixed lock
     */
    private $_lock;

    /**
     * @var string path
     */
    private $_path;

    /**
     * @var System system
     */
    protected $_system;

    /**
     * @var SystemCounter systemCounter
     */
    protected $_systemCounter;

    /**
     * Constructor
     * @param $cachePath
     * @param $licenseFile
     */
    public function __construct($cachePath = null, $licenseFile = null) {
        if ($cachePath === null) {
            $cachePath = Yii::app()->params["license"]["cache"];
        }

        $this->setCachePath($cachePath);

        if ($licenseFile === null) {
            $licenseFile = Yii::app()->params["license"]["file"];
        }

        $this->_path = $licenseFile;
        $this->_system = Yii::app()->system->getModel();
        $this->_systemCounter = new SystemCounter();
        $this->_load();
    }

    /**
     * Get default limits
     * @return array
     */
    public function getDefaultLimits() {
        return [
            self::LIMIT_RECIPIENTS => 500,
        ];
    }

    /**
     * Get default limit
     * @param $name
     * @return mixed|null
     */
    public function getDefaultLimit($name) {
        $limits = $this->getDefaultLimits();

        if (!isset($limits[$name])) {
            return false;
        }

        return $limits[$name];
    }

    /**
     * Get license limits
     * @return array
     */
    public static function getLimits($translate = true) {
        $lng = $translate ? null : "en";

        return [
            self::LIMIT_RECIPIENTS => __t("Recipients", [], false, $lng),
        ];
    }

    /**
     * Get options
     * @return array
     */
    public function getOptions() {
        $cls = new ReflectionClass(__CLASS__);
        $options = [];

        foreach ($cls->getConstants() as $constant => $value) {
            if (substr($constant, 0, 7) == "OPTION_") {
                $options[] = $value;
            }
        }

        return $options;
    }

    /**
     * @inheritdoc
     */
    public function getCachePath($url = "") {
        return $this->cachePath;
    }

    /**
     * Lock license
     * @throws Exception
     */
    private function _lock() {
        $lock = Yii::app()->params["license"]["lock"];
        $this->_lock = @fopen($lock, "w");

        if (!$this->_lock || !@flock($this->_lock, LOCK_EX)) {
            throw new Exception("Failed to obtain the license lock.");
        }

        try {
            FileManager::chmod($lock, 0777);
        } catch (Exception $e) {
            // pass
        }
    }

    /**
     * Unlock license
     */
    private function _unlock() {
        @flock($this->_lock, LOCK_UN);
        @fclose($this->_lock);
    }

    /**
     * Parse license and return a JSON object
     * @param $license
     * @return mixed|string
     * @throws Exception
     */
    public function parse($license) {
        $license = base64_decode($license);
        $iv = substr($license, 0, 16);
        $license = substr($license, 16);

        if (strlen($iv) < 16) {
            throw new Exception("Invalid license.");
        }

        $license = @mcrypt_decrypt(
            MCRYPT_RIJNDAEL_128,
            Yii::app()->params["license"]["key"],
            $license,
            MCRYPT_MODE_CBC,
            $iv
        );

        if ($license === false) {
            throw new Exception("Invalid license.");
        }

        $license = substr($license, 0, -(ord(substr($license, -1, 1))));
        $license = json_decode($license, true);

        if ($license === null) {
            throw new Exception("Invalid license.");
        }

        return $license;
    }

    /**
     * Get license data
     * @param $license
     * @return array
     */
    private function _getData($license) {
        try {
            $license = $this->parse($license);
        } catch (Exception $e) {
            $license = [];
        }

        $type = $license["type"] ?? self::TYPE_DEMO;
        $priority = $license["priority"] ?? 0;
        $expires = $license["expires_at"] ?? null;
        $limits = $license["limits"] ?? [];
        $workstationId = $license["workstation_id"] ?? null;
        $workstationKey = $license["workstation_key"] ?? null;
        $resetCounters = $license["reset_counters"] ?? null;
        $supportHours = $license["support_hours"] ?? null;

        if (!in_array($type, [self::TYPE_DEMO, self::TYPE_COMMERCIAL])) {
            $type = self::TYPE_DEMO;
        }

        if (YII_DEBUG) {
            $type = self::TYPE_COMMERCIAL;
        }

        $parsed = [
            "type" => $type,
            "priority" => $priority,
            "expires_at" => $expires,
            "limits" => $limits,
            "workstation_id" => $workstationId,
            "workstation_key" => $workstationKey,
            "reset_counters" => $resetCounters,
            "support_hours" => $supportHours,
        ];

        return $parsed;
    }

    /**
     * Load license data
     */
    private function _load() {
        $this->_lock();

        try {
            $this->type = self::TYPE_DEMO;
            $this->expiresAt = null;
            $this->_limits = [];
            $this->_workstationId = null;
            $this->_workstationKey = null;

            if (file_exists($this->_path)) {
                $license = FileManager::fileGetContents($this->_path);

                if ($license) {
                    $license = $this->_getData($license);
                    $expires = $license["expires_at"] ? new DateTime($license["expires_at"]) : null;
                    $expired = false;

                    if ($expires) {
                        $now = new DateTime();
                        $expired = $expires < $now;
                    }

                    if (!$expired) {
                        $this->type = $license["type"];
                        $this->priority = $license["priority"];
                        $this->expiresAt = $expires;
                        $this->_limits = $license["limits"];
                        $this->_workstationId = $license["workstation_id"];
                        $this->_workstationKey = $license["workstation_key"];
                        $this->supportHours = $license["support_hours"];
                    }
                }
            }
        } catch (Exception $ex) {
            // pass
        }

        $this->_unlock();
    }

    /**
     * Save license
     * @param $license
     * @throws Exception
     */
    private function _save($license) {
        $this->_lock();

        try {
            FileManager::filePutContents($this->_path, $license);
            FileManager::chmod($this->_path, 0777);
        } catch (Exception $e) {
            // pass
        }

        $this->_unlock();
    }

    /**
     * Check if license is equal to current
     * @param $license
     * @return bool
     */
    private function _equalToCurrent($license) {
        $equal = true;
        $parsed = $this->_getData($license);

        if ($parsed["reset_counters"]) {
            $sm = new SystemManager();
            $sm->resetLicenseCounters();
        }

        if ($parsed["type"] != $this->type ||
            $parsed["priority"] != $this->priority ||
            $parsed["expires_at"] != $this->expiresAt ||
            count($parsed["limits"]) != count($this->_limits) ||
            $parsed["workstation_id"] != $this->_system->workstation_id ||
            $parsed["workstation_key"] != $this->_system->workstation_key
        ) {
            $equal = false;
        }

        foreach ($this->_limits as $name => $value) {
            if (!isset($parsed["limits"][$name]) || $parsed["limits"][$name] != $value) {
                $equal = false;
                break;
            }
        }

        return $equal;
    }

    /**
     * Check if license is expired
     * @param DateInterval|null $in
     * @return bool
     */
    public function isExpires($in = null) {
        if (!$in) {
            $in = new DateInterval(self::EXPIRES_IN_DEFAULT);
        }

        $expires = $this->expiresAt ? clone($this->expiresAt) : null;
        $expired = false;

        if ($expires) {
            $now = new DateTime();
            $expired = $expires->sub($in) <= $now;
        } elseif ($this->type === self::TYPE_COMMERCIAL) {
            $expired = true;
        }

        return $expired;
    }

    /**
     * Set license
     * @param $license
     */
    public function set($license) {
        if ($this->_equalToCurrent($license)) {
            return;
        }

        $this->_save($license);
        $this->_load();

        if ($this->_workstationId && $this->_workstationKey) {
            $this->_system->workstation_id = $this->_workstationId;
            $this->_system->workstation_key = $this->_workstationKey;
            $this->_system->save();
        }
    }

    /**
     * Get limit option
     * @param $name
     * @return bool
     */
    public function getOption($name) {
        if (YII_DEBUG) {
            return true;
        }

        if ($this->type == self::TYPE_COMMERCIAL) {
            $option = isset($this->_limits[$name]) && ($this->_limits[$name] === "true");
        } else {
            $option = $this->getDefaultLimit($name);
        }

        return $option;
    }

    /**
     * Get limit
     * @param $name
     * @return int
     */
    public function getLimit($name) {
        $limit = 0;

        if (YII_DEBUG || (defined("YII_SKIP_LICENSE_CHECK") && YII_SKIP_LICENSE_CHECK)) {
            return 0;
        }

        if ($this->type == self::TYPE_COMMERCIAL) {
            if (isset($this->_limits[$name])) {
                $limit = is_numeric($this->_limits[$name]) ? intval($this->_limits[$name]) : $this->_limits[$name];
            }
        } else {
            switch ($name) {
                case self::LIMIT_RECIPIENTS:
                    $limit = $this->getDefaultLimit(self::LIMIT_RECIPIENTS);
                    break;
            }
        }

        return $limit;
    }

    /**
     * Check if value is within the given license limit
     * @param $name
     * @param $value
     * @return bool
     */
    public function checkLimit($name, $value) {
        $limit = $this->getLimit($name);

        if ($limit == 0) {
            return true;
        }

        return $limit > $value;
    }

    /**
     * Check if value exists in limit array
     * @param $name
     * @param $value
     * @return bool
     */
    public function checkArrayLimit($name, $value) {
        $limit = $this->getLimit($name);

        // limit not specified
        if (!$limit || YII_DEBUG) {
            return true;
        }

        $limit = explode(\',\', $limit);

        return in_array($value, $limit);
    }

    /**
     * Add license log
     * @param $type
     * @param $value
     * @param User|null $user
     * @throws Exception
     */
    public static function log($type, $value, User $user = null) {
        if (!in_array($type, LicenseLog::$types)) {
            return;
        }

        $um = new UserManager();

        $log = new LicenseLog();
        $log->type = $type;
        $log->value = $value;
        $log->user = $um->getUserName($user);
        $log->save();
    }

    /**
     * Revert last log by type
     * @param $type
     * @param $value
     */
    public static function revertLog($type, $value) {
        if (!in_array($type, LicenseLog::$types)) {
            return;
        }

        $log = LicenseLog::model()->findByAttributes([
            "type" => $type,
            "value" => SecurityManager::encrypt($value)
        ]);

        if (!$log) {
            return;
        }

        $log->delete();
    }

    /**
     * Get License prices
     * @return array
     * @throws Exception
     */
    public function getPrices() {
        $prices = [];

        if ($this->cacheIsAvailable()) {
            $prices = $this->getCache();

            if (!is_array($prices)) {
                $prices = [];
            }
        }

        return $prices;
    }

    /**
     * Get License prices
     * @return array
     */
    public function getLimitPrices() {
        // @TODO: fix in 4.3-4.4, get pricing from Lust
        return [
            self::LIMIT_RECIPIENTS => 3.5
        ];
    }

    /**
     * Save license prices
     * @param array $prices
     */
    public function setPrices($prices) {
        $this->writeCache($prices);
    }

    /**
     * Get limits for exceed check
     * @return array
     */
    public function getLimitsForExceedCheck() {
        return [
            self::LIMIT_RECIPIENTS => $this->_systemCounter->license_counter_recipients,
        ];
    }

    /**
     * Get exceeded limits
     * @return array
     */
    public function getExceededLimits() {
        $limits = $this->getLimitsForExceedCheck();

        $exceeded = [];

        foreach ($limits as $limit => $value) {
            if (!$this->checkLimit($limit, $value)) {
                $exceeded[] = $limit;
            }
        }

        return $exceeded;
    }

    /**
     * Get almost exceeded limits
     * @return array
     */
    public function getAboutToExceedLimits() {
        $limits = $this->getLimitsForExceedCheck();

        $exceeded = [];
        $license = new License();

        foreach ($limits as $limit => $value) {
            $max = $license->getLimit($limit);

            if ($max > 0 && $value / $max >= Yii::app()->params["license"]["expireWarningThreshold"]) {
                $exceeded[] = $limit;
            }
        }

        return $exceeded;
    }

    /**
     * Get limit titles
     * @return array
     */
    public function getLimitTitles() {
        return [
            self::LIMIT_RECIPIENTS => "Recipients used",
            self::OPTION_2FA => "2-Factor Authentication",
            self::OPTION_LDAP_SYNC => "LDAP Sync",
            self::OPTION_SSL_CERTS => "SSL Certificates",
            self::OPTION_API => "Rest API",
            self::OPTION_DMZ_MODE => "DMZ Mode",
            self::OPTION_SCHEDULE_RANDOMIZATION => "Scheduler Randomization",
            self::OPTION_ADVANCED_REPORTS => "Comprehensive Reporting",
            self::OPTION_BOUNCE_OOO_REPORTING => "Bounce and Out-of-Office Reporting",
            self::OPTION_CLIENT_VIEW_ACCOUNTS => "Client View Accounts",
            self::OPTION_RECIPIENT_REPUTATION => "Incident User Reputation Profiles",
            self::OPTION_RECIPIENT_HISTORY => "Recipients History",
            self::OPTION_ACCESS_CONTROL => "Role-Based Access Controls",
            self::OPTION_USER_GROUPS => "Multi-Layered User Groups",
            self::OPTION_LDAP_API => "LDAP API",
            self::OPTION_SAML_SSO => "SAML Single Sign-On (SSO)",
            self::OPTION_DOMAIN_API => "Domain API",
            self::OPTION_HOMEPAGE_CREATION => "Custom Homepage Creation",
            self::OPTION_URL_SHORTENING => "URL Shortening",
            self::OPTION_BENCHMARK => "Benchmark",
            self::OPTION_VIDEO_TRACKING => "Advanced Video Tracking",
            self::OPTION_QUIZ_TRACKING => "Advanced Quiz Tracking",
            self::OPTION_LANDING_PAGE_TIME_TRACKING => "Landing Page Time Tracking",
            self::OPTION_REALTIME_DASHBOARD => "Realtime Dashboard",
            self::OPTION_ANONYMIZATION => "Support for Anonymization and Data Protection",
            self::OPTION_REMINDERS => "Reminders",
            self::OPTION_ADMIN_INTERFACE => "Multi-Language Admin Interface",
            self::OPTION_RULE_BASED_ANALYSIS => "Custom Rule-Based Analysis",
            self::OPTION_MOBILE_RESPONSIVE => "Mobile-Responsive",
            self::OPTION_INCIDENT_HANDLING => "Incidents Handling",
            self::OPTION_INCIDENT_FEEDBACK => "Incident Auto Feedback",
            self::OPTION_INCIDENT_CLIENT => "Incident Clients",
            self::OPTION_DEEP_INSPECTION => "Deep Inspection Request",
            self::OPTION_TRAINING_DIPLOMA => "Awareness Education Diploma",
            self::OPTION_ENDUSERS => "End user Training Portal",
            self::OPTION_DOUBLE_BARREL_ATTACKS => "Double Barrel Attacks",
            self::OPTION_MIXED_ATTACKS => "Mixed Attacks",
            self::OPTION_MEDIA_ATTACKS => "Portable Media Attacks",
            self::OPTION_SMISHING_ATTACKS => "SMiShing",
            self::OPTION_JAVA_DROPPER => "Java-Based Attacks",
            self::OPTION_MALWARE_SIMULATION => "Simultaneous Attack Template Usage",
            self::OPTION_FILE_ATTACKS => "File-Based Attacks",
            self::OPTION_PENTEST_KIT => "Pentest Kit",
            self::OPTION_EXECUTABLE_PDF => "PDF-Based Attacks",
            self::OPTION_MAIL_WEB_FILTER_TEST => "Mail and Web Filter Test",
            self::OPTION_URL_ATTACK => "Attack URL Variations",
            self::OPTION_ENTRY_ATTACK => "Data Entry Attacks",
            self::OPTION_HYPERLINK_ATTACKS => "Hyperlink Attacks",
            self::OPTION_LEVEL_BASED_ATTACKS => "Level-Based Attacks",
            self::OPTION_RANSOMWARE_SIMULATION => "Ransomware Simulation Attacks",
            self::OPTION_TRAINING_SIMULATION => "Standard Phishing & Training Simulation",
            self::OPTION_SPEAR_SIMULATION => "Spear Phishing Simulation",
            self::OPTION_ATTACK_SIMULATION_INTEGRATION => "Integration with Attack Simulations",
            self::OPTION_SPOOFING_TEST => "Spoofing Test",
            self::OPTION_IDENTITY_ATTACKS => "Identify Attacks with Common Patterns",
            self::OPTION_AWARENESS_WEBSITE => "Rich Media Awareness Training",
            self::OPTION_SCORM_EXPORT => "SCORM Import/Export",
            self::OPTION_AUTHORING_TOOLKIT => "e-Learning Authoring Toolkit",
            self::OPTION_APPROVAL_WORKFLOWS => "Approval Workflows",
            self::OPTION_REPUTATION_BASED_LEARNING => "Reputation Based Learning",
            self::OPTION_DYNAMIC_TRAINING_HINTS => "Dynamic Training Hints",
            self::OPTION_EXPORT => "Export Features",
            self::OPTION_INTERACTIVE_SESSION => "Interactive Sessions",
            self::OPTION_ADVANCED_AUTHENTICATION => "Advanced Security Features",
            self::OPTION_CERT_AUTHENTICATION => "Certificate-Based Authentication",
            self::OPTION_MULTI_TENANT => "Multi-Tenant View-Only Access",
            self::OPTION_THREAT_ANALYSIS => "Threat Analysis",
            self::OPTION_THREAT_MITIGATION => "Threat Mitigation",
            self::OPTION_ACTIVE_DETECTION => "Active and Passive Client Vulnerability Detection",
            self::OPTION_EMAIL_SPIDER => "Mail Scanner",
            self::OPTION_DEFAULT_CAMPAIGN_TEMPLATES => "Campaign Templates",
            self::OPTION_CAMPAIGN_CHECKS => "Campaign Checks",
            self::OPTION_CAMPAIGN_COMPARISON => "Campaigns Comparison",
            self::OPTION_PERFORMANCE_CALCULATOR => "Performance Tools",
            self::OPTION_DIGITAL_SIGNATURES => "Digital Signatures",
            self::OPTION_SUPPORT_PROXY => "Flexible e-Mail Delivery Methods",
            self::OPTION_DKIM_MIME => "DKIM / S/MIME Support for Phishing E-mails",
            self::OPTION_MAIL_COMMUNICATION => "Full Mail Communication Client",
            self::OPTION_WEBSITE_CLONER => "Website Cloner",
            self::OPTION_ENTRY_TOOLKIT => "Data Entry Validation Toolkit",
            self::OPTION_URL_REDIRECTION => "Powerful URL Redirection Toolkit",
            self::OPTION_MALWARE_TOOLKIT => "Malware Testing Toolkit",
            self::OPTION_BASIC_ATTACK_TEMPLATES => "Basic Attack Templates",
            self::OPTION_EXTENDED_ATTACK_TEMPLATES => "Extended Attack Template Library",
            self::OPTION_FULL_ATTACT_TEMPLATES => "Full Attack Template Library",
            self::OPTION_ATTACK_TEMPLATE_LIBRARY => "Multilingual Attack Template Library",
            self::OPTION_TRAINING_LIBRATY => "Training Library",
            self::OPTION_BASIC_EDUCATION_LIBRARY => "Basic Education Template Library",
            self::OPTION_EXTENDED_EDUCATION_LIBRARY => "Extended Education Template Library",
            self::OPTION_FULL_EDUCATION_LIBRARY => "Full Education Template Library",
            self::OPTION_MICROLEARNING_MODULE => "Microlearning Modules",
            self::OPTION_SUPPROT_STANDART => "Support Subscription: Standard",
            self::OPTION_SUPPORT_BUSINESS => "Support Subscription: Business",
            self::OPTION_SUPPORT_PREMIUM => "Support Subscription: Premium",
            self::OPTION_VPS_PROFESSIONAL => "Virtualized Private Server, Professional",
            self::OPTION_VPS_PREMIUM => "Virtualized Private Server, Premium",
            self::OPTION_VPS_ULTRA => "Virtualized Private Server, Ultra",
            self::OPTION_SECTOR_TEMPLATES => "Sector Specific Templates",
            self::OPTION_TEMPLATE_CREATION => "Custom Template Creation",
            self::OPTION_GMAIL => "Gmail Plugin",
            self::OPTION_OUTLOOK => "Outlook Plugin",
            self::OPTION_OUTLOOK365 => "Outlook 365 Plugin",
            self::OPTION_PLUGIN_CUSTOMIZATION => "Plugin Customization Options",
            self::OPTION_CLIENT_COMPATIBLE => "Multi-Client Compatible",
            self::OPTION_VIDEO_CUSTOMIZATOR => "Video Customization",
            self::OPTION_VIDEO_IMPORT_EXPORT => "Video Import/Export",
            self::OPTION_OFFLINE_SUPPORT => "Offline Training Support",
            self::OPTION_EASY_INSTALLATION => "Easy Installation",
            self::OPTION_SETUP_WIZARD => "Setup Wizard with Risk-Based Guidance",
            self::OPTION_INSTALLATION_SUPPORT => "Installation Support",
            self::OPTION_VIDEO_CREATION => "Custom Video Creation",
            self::OPTION_STATIC_TRAINING => "Static Training Support",
            self::OPTION_CONSULTING_SERVICE => "Consulting Service Subscription",
            self::OPTION_BUSINESS_INTELLIGENCE => "Business Intelligence",
            self::OPTION_THIRD_PARTY_INTEGRATION => "Third Party Integration",
            self::OPTION_BEHAVIOR_REINFORCEMENT => "Positive Behavior Reinforcement",
        ];
    }

    /**
     * Get limit title
     * @param $limit
     * @return string
     */
    public function getLimitTitle($limit) {
        $titles = $this->getLimitTitles();

        return $titles[$limit] ?? ucwords(str_replace("_", " ", $limit));
    }
}
'