import re
from typing import Optional

class SecureSkill:
    def __init__(self):
        self.max_input_length = 1024
        self.forbidden_commands = ['rm', 'dd', 'format', 'del']
    
    def validate_file_path(self, path: str) -> bool:
        """Validate file path to prevent directory traversal"""
        # Prevent path traversal attacks
        normalized = os.path.normpath(path)
        if ".." in normalized:
            return False
        
        # Check against allowed directories
        allowed_dirs = ['/documents', '/projects']
        return any(normalized.startswith(d) for d in allowed_dirs)
    
    def sanitize_command(self, cmd: str) -> Optional[str]:
        """Sanitize shell commands"""
        for forbidden in self.forbidden_commands:
            if re.search(rf'\b{forbidden}\b', cmd, re.IGNORECASE):
                return None
        
        # Additional validation
        if len(cmd) > self.max_input_length:
            return None
        
        return cmd.strip()
    
    def process_user_input(self, user_input: str) -> bool:
        """Multi-layer input validation"""
        # Layer 1: Length check
        if len(user_input) > self.max_input_length:
            raise ValueError("Input too long")
        
        # Layer 2: Character validation
        if not re.match(r'^[a-zA-Z0-9\s\-_\.]+$', user_input):
            raise ValueError("Invalid characters")
        
        # Layer 3: Semantic validation
        return True

# WRONG - Information disclosure
def process_file(filename):
    try:
        with open(filename) as f:
            return process(f)
    except Exception as e:
        return f"Error: {e}"  # Reveals system paths, internals

# CORRECT - Safe error handling
def process_file(filename):
    try:
        validate_file_path(filename)
        with open(filename) as f:
            return process(f)
    except FileNotFoundError:
        logger.warning(f"File not found: {filename}")
        return "Unable to process file"
    except Exception as e:
        logger.error(f"Processing error", exc_info=True)
        return "An error occurred processing your request"

import secrets
import json
from cryptography.fernet import Fernet

class SecureStorage:
    def __init__(self):
        self.cipher_key = os.environ.get('SKILL_CIPHER_KEY')
        if not self.cipher_key:
            raise ValueError("SKILL_CIPHER_KEY not configured")
        self.cipher = Fernet(self.cipher_key.encode())
    
    def store_credential(self, credential_type: str, value: str):
        """Encrypt and store credentials securely"""
        encrypted = self.cipher.encrypt(value.encode())
        
        storage = {
            'type': credential_type,
            'data': encrypted.decode(),
            'timestamp': datetime.now().isoformat(),
            'salt': secrets.token_hex(16)
        }
        
        # Store to secure location
        self._save_to_vault(credential_type, storage)
    
    def retrieve_credential(self, credential_type: str):
        """Retrieve and decrypt credentials"""
        storage = self._load_from_vault(credential_type)
        return self.cipher.decrypt(storage['data'].encode()).decode()

import logging
import metrics

class SkillMonitoring:
    def __init__(self):
        self.logger = logging.getLogger('skill-monitor')
        
    def log_execution(self, skill_name, duration, success):
        """Log skill execution metrics"""
        metrics.histogram(
            'skill.execution.duration_ms',
            duration,
            tags={'skill': skill_name, 'success': success}
        )
        
    def track_security_event(self, event_type, details):
        """Track security-relevant events"""
        self.logger.warning(
            f"Security event: {event_type}",
            extra={'details': details, 'timestamp': datetime.now()}
        )
        metrics.increment(
            'skill.security_events',
            tags={'event_type': event_type}
        )