Struct SecurityPolicy 

pub struct SecurityPolicy {
    pub allow_unsafe_code: bool,
    pub require_signatures: bool,
    pub min_trust_level: u8,
    pub max_complexity: u32,
    pub dangerous_permissions: Vec<String>,
    pub restricted_apis: Vec<String>,
}

Security policy configuration for the plugin system

The SecurityPolicy defines the security requirements and restrictions for plugin validation and execution. It provides configurable security levels to balance functionality with safety requirements.

Security Levels

• Strict: Maximum security with signature requirements and minimal permissions
• Standard: Balanced security for production environments
• Permissive: Relaxed security for development and testing

Examples

use sklears_core::plugin::{SecurityPolicy, Permission};

// Create a strict security policy
let strict_policy = SecurityPolicy::strict();
assert!(strict_policy.require_signatures);
assert!(!strict_policy.allow_unsafe_code);

// Create a custom policy
let custom_policy = SecurityPolicy {
    allow_unsafe_code: false,
    require_signatures: true,
    min_trust_level: 7,
    max_complexity: 15,
    dangerous_permissions: vec![
        "file_system_write".to_string(),
        "network_access".to_string(),
    ],
    restricted_apis: vec![
        "std::process::Command".to_string(),
    ],
};

Fields

allow_unsafe_code: bool

Whether to allow plugins with unsafe code blocks

require_signatures: bool

Whether digital signatures are required for plugins

min_trust_level: u8

Minimum trust level required for plugin publishers (0-10)

max_complexity: u32

Maximum allowed cyclomatic complexity for plugin code

dangerous_permissions: Vec<String>

List of dangerous permissions that trigger warnings

restricted_apis: Vec<String>

List of restricted API patterns that are not allowed

Implementations

impl SecurityPolicy

pub fn strict() -> Self

Create a strict security policy suitable for production environments

This policy provides maximum security with signature requirements, no unsafe code, and minimal dangerous permissions.

Examples

use sklears_core::plugin::SecurityPolicy;

let policy = SecurityPolicy::strict();
assert!(policy.require_signatures);
assert!(!policy.allow_unsafe_code);
assert_eq!(policy.min_trust_level, 8);

pub fn standard() -> Self

Create a standard security policy for typical production use

Balances security with functionality, allowing more flexibility than strict mode while maintaining essential protections.

Examples

use sklears_core::plugin::SecurityPolicy;

let policy = SecurityPolicy::standard();
assert!(policy.require_signatures);
assert!(!policy.allow_unsafe_code);
assert_eq!(policy.min_trust_level, 5);

pub fn permissive() -> Self

Create a permissive security policy for development and testing

Provides minimal security restrictions to enable rapid development and testing. Should not be used in production environments.

Examples

use sklears_core::plugin::SecurityPolicy;

let policy = SecurityPolicy::permissive();
assert!(!policy.require_signatures);
assert!(policy.allow_unsafe_code);
assert_eq!(policy.min_trust_level, 0);

pub fn is_dangerous_permission(&self, permission: &Permission) -> bool

Check if a permission is considered dangerous

Dangerous permissions are those that could potentially be used maliciously or cause system damage if misused.

Arguments

• permission - The permission to check

Returns

true if the permission is considered dangerous, false otherwise.

Examples

use sklears_core::plugin::{SecurityPolicy, Permission};

let policy = SecurityPolicy::standard();
assert!(policy.is_dangerous_permission(&Permission::FileSystemWrite));
assert!(!policy.is_dangerous_permission(&Permission::FileSystemRead));

pub fn is_restricted_api(&self, api: &str) -> bool

Check if an API call is restricted

Restricted APIs are those that are prohibited from use in plugins due to security concerns or system stability issues.

Arguments

• api - The API call pattern to check

Returns

true if the API is restricted, false otherwise.

Examples

use sklears_core::plugin::SecurityPolicy;

let policy = SecurityPolicy::standard();
assert!(policy.is_restricted_api("std::process::Command"));
assert!(!policy.is_restricted_api("std::fs::read_to_string"));

pub fn add_dangerous_permission(&mut self, permission: String)

Add a dangerous permission to the policy

Arguments

• permission - The permission name to add as dangerous

pub fn remove_dangerous_permission(&mut self, permission: &str)

Remove a dangerous permission from the policy

Arguments

• permission - The permission name to remove from dangerous list

pub fn add_restricted_api(&mut self, api_pattern: String)

Add a restricted API pattern to the policy

Arguments

• api_pattern - The API pattern to restrict

pub fn remove_restricted_api(&mut self, api_pattern: &str)

Remove a restricted API pattern from the policy

Arguments

• api_pattern - The API pattern to remove from restrictions

pub fn validate(&self) -> Result<()>

Validate the policy configuration

Ensures that the policy configuration is consistent and valid.

Returns

Ok(()) if the policy is valid, error otherwise.

Trait Implementations

impl Clone for SecurityPolicy

fn clone(&self) -> SecurityPolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SecurityPolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SecurityPolicy

fn default() -> Self

Returns the “default value” for a type.