security-by-design

name	security-by-design
description	API security, MCP tool security, input validation, rate limiting, audit logging, secure authentication, and defense-in-depth principles
license	MIT

Security By Design Skill

Context

This skill applies when:

• Implementing MCP protocol tools and handlers
• Exposing European Parliament data through APIs
• Handling user inputs or external data sources
• Implementing authentication or authorization mechanisms
• Processing sensitive or classified information
• Designing rate limiting or abuse prevention
• Implementing audit logging and monitoring
• Writing security-critical validation logic
• Handling errors and exceptions securely
• Configuring network security or TLS

Security is foundational, not optional. Every feature must be designed with security in mind from the start, following the principle of "secure by default" and implementing defense-in-depth strategies aligned with Hack23 AB's ISMS policies.

Rules

1. Never Trust Input: Validate and sanitize all user inputs - treat everything as potentially malicious
2. Fail Securely: Systems must fail to a secure state, never expose sensitive information in errors
3. Principle of Least Privilege: Grant minimal permissions required for functionality, nothing more
4. Defense in Depth: Implement multiple overlapping security controls (validation + rate limiting + audit logging)
5. Encrypt Everything: Use TLS 1.3+ for transit, AES-256 for at rest, never store secrets in plaintext
6. Audit All Actions: Log authentication attempts, authorization failures, input validation errors
7. Rate Limit Aggressively: Protect against abuse, DoS attacks, and resource exhaustion
8. Validate Schema: Use strict schema validation for all MCP tool inputs and outputs
9. Sanitize Output: Encode data appropriately to prevent injection attacks (XSS, command injection)
10. Secure Defaults: All features must be secure by default, require opt-in for permissive settings
11. No Secrets in Code: Never commit API keys, tokens, or credentials to source control
12. Regular Updates: Keep dependencies updated, scan for vulnerabilities continuously
13. Assume Breach: Design systems assuming attackers will get in - limit blast radius
14. Document Security: Reference ISMS policies, document threat models and security controls
15. Test Security: Write tests for authentication, authorization, input validation, and error handling

Examples

✅ Good Pattern: Comprehensive Input Validation

/**
 * Input validation service for MCP tool parameters
 * 
 * Security controls:
 * - Whitelist validation (only allow known-good patterns)
 * - Length limits to prevent buffer overflow or DoS
 * - Type checking to prevent type confusion
 * - Character set restrictions to prevent injection
 * - Sanitization to remove dangerous content
 * 
 * ISMS Policy: SC-002 (Secure Coding Standards)
 * Compliance: OWASP Top 10 (A03:2021 - Injection), ISO 27001:2022 A.8.3
 * 
 * @security Defense: SQL injection, XSS, command injection, path traversal
 */
export class InputValidationService {
  private readonly MAX_KEYWORD_LENGTH = 200;
  private readonly MAX_DOCUMENT_ID_LENGTH = 50;
  private readonly MAX_ARRAY_SIZE = 100;
  
  // Whitelist: Only alphanumeric, spaces, hyphens, underscores
  private readonly SAFE_KEYWORD_PATTERN = /^[a-zA-Z0-9\s\-_]+$/;
  
  // European Parliament document ID format: EP-YYYYMMDD-NNNNN
  private readonly DOCUMENT_ID_PATTERN = /^EP-\d{8}-\d{5}$/;
  
  // ISO 8601 date format: YYYY-MM-DD
  private readonly DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
  
  // Allowed document types (whitelist)
  private readonly ALLOWED_DOCUMENT_TYPES = new Set([
    'REPORT',
    'RESOLUTION',
    ,
    ,
    ,
    ,
  ]);
  
  
  (: ):  {
     ( params !==  || params === ) {
        ();
    }
    
     query = params  <, >;
    
     {
      : .(query.),
      : .(query.),
      : .(query., ),
      : .(query., ),
      : .(query.),
    };
  }
  
  
   (: ):  {
     ( value !== ) {
        ();
    }
    
     trimmed = value.();
    
    
     (trimmed. === ) {
        ();
    }
    
     (trimmed. > .) {
        (
        
      );
    }
    
    
     (!..(trimmed)) {
        (
        
      );
    }
    
    
     trimmed.(, );
  }
  
  
   (: ):  |  {
     (value ===  || value === ) {
       ;
    }
    
     ( value !== ) {
        ();
    }
    
     normalized = value.().();
    
    
     (!..(normalized)) {
        (
        
      );
    }
    
     normalized;
  }
  
  
   (: , : ):  |  {
     (value ===  || value === ) {
       ;
    }
    
     ( value !== ) {
        ();
    }
    
    
     (!..(value)) {
        (
        
      );
    }
    
    
     date =  (value);
     ((date.())) {
        ();
    }
    
    
     minDate =  ();
     maxDate =  ();
    maxDate.(maxDate.() + ); 
    
     (date < minDate || date > maxDate) {
        (
        
      );
    }
    
     value;
  }
  
  
   (: ):  {
     (value ===  || value === ) {
       ; 
    }
    
     num = (value);
    
    
     (!.(num)) {
        ();
    }
    
    
     (!.(num)) {
        ();
    }
    
    
     (num <  || num > ) {
        ();
    }
    
     num;
  }
  
  
  (: ):  {
     ( value !== ) {
        ();
    }
    
     trimmed = value.();
    
    
     (trimmed. > .) {
        ();
    }
    
    
     (!..(trimmed)) {
        (
        
      );
    }
    
     trimmed;
  }
  
  
  validateArray<T>(
    : ,
    :  T,
    :  = .
  ): T[] {
     (!.(value)) {
        ();
    }
    
    
     (value. === ) {
        ();
    }
    
     (value. > maxSize) {
        (
        
      );
    }
    
    
     value.( {
       {
         (item);
      }  (error) {
          (
          
        );
      }
    });
  }
}


     {
  () {
    
    (message);
    . = ;
  }
}

✅ Good Pattern: Rate Limiting with Multiple Strategies

/**
 * Multi-layer rate limiting for MCP tool requests
 * 
 * Rate limiting strategies:
 * 1. Fixed window (simple, prevents burst)
 * 2. Sliding window (accurate, prevents boundary gaming)
 * 3. Token bucket (flexible, allows burst within limits)
 * 4. IP-based limiting (prevents distributed abuse)
 * 
 * ISMS Policy: AC-002 (Access Control - Rate Limiting)
 * Compliance: NIST CSF PR.AC-4, CIS Control 13.3, OWASP API Security (API4:2023)
 * 
 * @security Defense: DoS attacks, brute force, resource exhaustion
 */
export class RateLimiter {
  private readonly fixedWindow = new Map<string, FixedWindowState>();
  private readonly slidingWindow = new Map<string, number[]>();
  
  // Rate limit: 100 requests per 15 minutes
  private readonly MAX_REQUESTS = 100;
  private readonly WINDOW_MS = 15 * 60 * 1000;
  
  // Burst limit: 10 requests per 10 seconds
  private readonly BURST_MAX = 10;
  private readonly BURST_WINDOW_MS = 10 * 1000;
  
  /**
   * Check rate limit for client
   * Uses sliding window algorithm for accuracy
   */
  async checkLimit(clientId: ): <> {
     now = .();
    
    
     .(clientId, now);
    
    
     .(clientId, now);
    
    
    .(clientId, now);
  }
  
  
    (: , : ): <> {
     requests = ..(clientId) || [];
    
     recentBurst = requests.(
       now - timestamp < .
    );
    
     (recentBurst. >= .) {
       oldestRequest = .(...recentBurst);
       retryAfter = .(
        (oldestRequest + . - now) / 
      );
      
      
       .(clientId, , recentBurst.);
      
        (
        ,
        retryAfter
      );
    }
  }
  
  
    (: , : ): <> {
     requests = ..(clientId) || [];
    
     recentRequests = requests.(
       now - timestamp < .
    );
    
     (recentRequests. >= .) {
       oldestRequest = .(...recentRequests);
       retryAfter = .(
        (oldestRequest + . - now) / 
      );
      
      
       .(clientId, , recentRequests.);
      
        (
        ,
        retryAfter
      );
    }
  }
  
  
   (: , : ):  {
     requests = ..(clientId) || [];
    
    
    requests.(now);
    
    
     filtered = requests.(
       now - timestamp < .
    );
    
    ..(clientId, filtered);
  }
  
  
    (
    : ,
    :  | ,
    : 
  ): <> {
     event = {
      :  ().(),
      : ,
      : ,
      : .(clientId), 
      : ,
      requestCount,
      :  ===  ? . : .,
      :  ===  ? . : .,
    };
    
    
     auditLogger.(event);
    
    
     (requestCount > . * ) {
       alerting.({
        : ,
        : .(clientId),
        : event,
      });
    }
  }
  
  
   (: ):  {
     crypto
      .()
      .(clientId)
      .()
      .(, );
  }
  
  
  ():  {
    ( {
       now = .();
      
       ( [clientId, requests]  ..()) {
         active = requests.(
           now - timestamp < .
        );
        
         (active. === ) {
          ..(clientId);
        }  {
          ..(clientId, active);
        }
      }
    },  * ); 
  }
}

     {
  () {
    (message);
    . = ;
  }
}

✅ Good Pattern: Comprehensive Audit Logging

/**
 * Security audit logging for MCP server operations
 * 
 * Logs all security-relevant events:
 * - Authentication attempts (success/failure)
 * - Authorization checks (granted/denied)
 * - Input validation failures
 * - Rate limit violations
 * - Configuration changes
 * - Error conditions
 * 
 * ISMS Policy: IM-001 (Incident Management), AU-001 (Audit Logging)
 * Compliance: ISO 27001:2022 A.8.15, NIST CSF DE.AE-3, CIS Control 8.2
 * 
 * @security Immutable audit trail for forensics and compliance
 */
export class AuditLogger {
  private readonly logStream: fs.WriteStream;
  
  constructor(logPath: string) {
    // Append-only log file for immutability
    this.logStream = fs.createWriteStream(logPath, {
      flags: 'a',
      encoding: 'utf8',
    });
    
    // Ensure logs are flushed on shutdown
    process.on('SIGTERM', () => this.close());
    process.on('SIGINT', () => this.close());
  }
  
  /**
   * Log security event
   * All events are JSON formatted with consistent schema
   */
  async log(event: AuditEvent): Promise<void> {
    const logEntry = {
      timestamp:  ().(),
      : crypto.(),
      : event.,
      : event.,
      : .(event.),
      : event.,
      : event.,
      : event.,
      : event.,
      : event. ? .(event.) : ,
    };
    
    
      ( {
      ..(
        .(logEntry) + ,
         {
           (error) {
            
            .(, error);
            (error);
          }  {
            ();
          }
        }
      );
    });
  }
  
  
   (
    : ,
    : ,
    ?: <, >
  ): <> {
     .({
      : ,
      : success ?  : ,
      actor,
      : ,
      : ,
      : success ?  : ,
      metadata,
    });
  }
  
  
   (
    : ,
    : ,
    : ,
    : 
  ): <> {
     .({
      : ,
      : granted ?  : ,
      actor,
      action,
      resource,
      : granted ?  : ,
    });
  }
  
  
   (
    : ,
    : ,
    : 
  ): <> {
     .({
      : ,
      : ,
      actor,
      : ,
      : tool,
      : ,
      : { errorType },
    });
  }
  
  
   (
    : ,
    : ,
    : ,
    ?: 
  ): <> {
     .({
      : ,
      : ,
      actor,
      : ,
      : tool,
      : success ?  : ,
      : { duration },
    });
  }
  
  
   (?: ):  {
     (!actor) {
       ;
    }
    
    
     crypto
      .()
      .(actor)
      .()
      .(, );
  }
  
  
   (: ):  {
     crypto
      .()
      .(ip)
      .()
      .(, );
  }
  
  
  ():  {
    ..();
  }
}

  {
  : ;
  :  |  |  | ;
  ?: ;
  : ;
  : ;
  :  |  |  | ;
  ?: <, >;
  ?: ;
}

✅ Good Pattern: Secure Error Handling

/**
 * Secure error handling for MCP tools
 * 
 * Security principles:
 * - Never expose internal implementation details
 * - Never echo user input in error messages
 * - Log detailed errors internally, return generic externally
 * - Fail securely (deny by default)
 * 
 * ISMS Policy: SC-002 (Secure Coding Standards)
 * Compliance: OWASP Top 10 (A05:2021 - Security Misconfiguration)
 */
export class SecureErrorHandler {
  constructor(
    private readonly auditLogger: AuditLogger
  ) {}
  
  /**
   * Handle error from MCP tool execution
   * Returns safe error message to client, logs details internally
   */
  async handleToolError(
    error: Error,
    context: ErrorContext
  ): Promise<ToolResponse> {
    // Log full error details for debugging (internal only)
    await this.auditLogger.log({
      type: 'TOOL_ERROR',
      severity: 'ERROR',
      actor: context.actor,
      action: context.action,
      resource: context.resource,
      outcome: 'FAILURE',
      metadata: {
        errorType: error.name,
        errorMessage: error.message,
        stackTrace: error.stack,
      },
    });
    
    
     safeMessage = .(error);
    
     {
      : ,
      : [{
        : ,
        : safeMessage,
      }],
    };
  }
  
  
   (: ):  {
    
     (error  ) {
       error.; 
    }
    
     (error  ) {
       error.; 
    }
    
     (error  ) {
       ;
    }
    
    
    
     ;
  }
}

  {
  : ;
  : ;
  : ;
}

     {
  () {
    (message);
    . = ;
  }
}

❌ Bad Pattern: No Input Validation

// Bad: Accepting user input without validation
export async function searchDocuments(query: any): Promise<Results> {
  // Direct use of unvalidated input - SQL injection vulnerability!
  const sql = `SELECT * FROM documents WHERE title LIKE '%${query.keywords}%'`;
  return await db.query(sql);
}

// Bad: Type assertion without validation
export async function getDocument(params: any): Promise<Document> {
  const id = params.documentId as string; // Unsafe cast!
  return await europeanParliamentApi.getDocument(id);
}

// Bad: No length limits - DoS vulnerability
export async function processText(text: string): Promise<string> {
  // What if text is 1GB? Server crashes!
  return text.toUpperCase();
}

❌ Bad Pattern: Exposing Sensitive Information

// Bad: Exposing internal error details
export async function handleRequest(req: Request): Promise<Response> {
  try {
    return await processRequest(req);
  } catch (error) {
    // NEVER expose stack traces, error details, or internal paths!
    return {
      error: error.message,
      stack: error.stack, // Exposes code structure!
      file: error.fileName, // Exposes internal paths!
    };
  }
}

// Bad: Echoing user input in errors
export function validateInput(input: string): void {
  if (input.includes('<script>')) {
    // NEVER echo user input - XSS vulnerability!
    throw new Error(`Invalid input: ${input}`);
  }
}

// Bad: Logging sensitive data
export async function authenticate(username: string, password: ): <> {
  .();
  
   (username, password);
}

❌ Bad Pattern: No Rate Limiting

// Bad: No rate limiting - DoS vulnerability
export async function searchDocuments(query: SearchQuery): Promise<Results> {
  // Anyone can make unlimited requests
  // European Parliament API will block us!
  // Server resources exhausted!
  return await europeanParliamentApi.search(query);
}

// Bad: No burst protection
export async function handleRequests(requests: Request[]): Promise<Response[]> {
  // Processing 10,000 requests simultaneously - server crash!
  return Promise.all(requests.map(r => processRequest(r)));
}

❌ Bad Pattern: Secrets in Code

// Bad: Hardcoded API key
const API_KEY = 'sk-1234567890abcdef'; // NEVER commit secrets!

// Bad: Credentials in config file (committed to Git)
const config = {
  database: {
    host: 'db.example.com',
    username: 'admin',
    password: 'SuperSecret123', // Committed to Git history forever!
  },
};

// Bad: API key in URL
const url = `https://api.example.com/data?apikey=${API_KEY}`;
// Logged in access logs, browser history, proxy logs!

References

Security Standards

• OWASP Top 10
• OWASP API Security Top 10
• OWASP ASVS
• CWE Top 25

ISMS Policies

Core:

• Information Security Policy — Security-by-design foundation
• Secure Development Policy — Secure coding, validation, testing, DevSecOps
• Open Source Policy — Supply chain, SBOM, SLSA, OSSF Scorecard

Supporting:

• Access Control Policy — Least privilege
• Cryptography Policy — TLS 1.3+, approved algorithms
• Privacy Policy — GDPR, data minimisation
• Data Classification Policy
• Vulnerability Management — CVSS-based SLAs
• Threat Modeling — STRIDE
• Incident Response Plan — NIST SP 800-61r2
• Change Management
• OWASP LLM Security Policy — MCP-specific
• AI Policy

Security Tools

• npm audit - Dependency vulnerability scanning
• Snyk - Continuous security monitoring
• OWASP Dependency-Check
• Semgrep - Static analysis security testing

Cryptography

• Node.js Crypto Module
• libsodium - Modern cryptography library
• TLS Best Practices

Remember

• Never trust input: Validate everything, sanitize always, encode appropriately
• Fail securely: Default deny, safe error messages, no information leakage
• Defense in depth: Multiple overlapping security controls
• Least privilege: Minimal permissions, need-to-know basis
• Audit everything: Log security events, monitor for anomalies
• Rate limit aggressively: Protect against abuse and DoS attacks
• Encrypt always: TLS 1.3+ for transit, AES-256 for at rest
• Secure by default: All features secure unless explicitly configured otherwise
• No secrets in code: Use environment variables, secret management systems
• Update dependencies: Patch vulnerabilities quickly, scan continuously
• Assume breach: Limit blast radius, segment networks, monitor for indicators
• Document security: Reference ISMS policies, explain threat mitigations
• Test security controls: Write tests for auth, authz, validation, encryption
• European Parliament data: Respect data protection regulations, handle sensitively
• MCP protocol: Validate tool schemas strictly, sanitize responses