Especificación de Inferencia de Permisos MCP¶

Versión: 1.0.0 Estado: Estándar Última actualización: 2025-01-30

Tabla de Contenidos¶

Introducción
Terminología
Categorías de Permisos
Modelo de Datos
Algoritmo de Inferencia
Comparación de Permisos
Evaluación de Riesgo
Esquema JSON
Ejemplos
Guías de Integración

1. Introducción¶

1.1 Propósito¶

Esta especificación define el Sistema de Inferencia de Permisos MCP, un mecanismo para detectar y catalogar automáticamente los permisos requeridos por un servidor MCP (Model Context Protocol) basándose en análisis estático de código.

El sistema analiza los hallazgos de seguridad de mcp-scan y los mapea a un modelo estructurado de permisos, permitiendo:

Transparencia: Los usuarios entienden qué capacidades requiere un servidor MCP
Comparación: Los permisos declarados pueden validarse contra el comportamiento real del código
Evaluación de riesgo: Se identifican permisos no declarados o excesivos
Aplicación de políticas: Las organizaciones pueden aplicar políticas de permisos

1.2 Alcance¶

Esta especificación cubre:

Definiciones de categorías de permisos
Estructuras de datos para representar permisos
El algoritmo de inferencia que mapea hallazgos a permisos
Lógica de comparación entre permisos declarados e inferidos
Clasificación de niveles de riesgo
Formato de salida JSON

1.3 Conformidad¶

Una implementación cumple con esta especificación si:

Implementa las ocho categorías de permisos definidas
Produce salida JSON que coincide con el esquema de la Sección 8
Calcula niveles de riesgo según la Sección 7
Sigue el algoritmo de inferencia descrito en la Sección 5

2. Terminología¶

Término	Definición
Servidor MCP	Un servidor que implementa el Model Context Protocol
Permiso	Una capacidad que un servidor MCP requiere para funcionar
Categoría	Una clasificación que agrupa permisos relacionados
Hallazgo	Un patrón de código relevante para seguridad detectado por mcp-scan
Permiso inferido	Un permiso detectado mediante análisis de código
Permiso declarado	Un permiso declarado explícitamente en un manifiesto
Confianza	El nivel de certeza de una detección de permiso
Sink	Una ubicación de código donde los datos fluyen a una operación sensible

3. Categorías de Permisos¶

El sistema define ocho categorías de permisos, cada una representando un dominio de capacidad distinto.

3.1 Exec (`exec`)¶

Descripción: Capacidad de ejecutar comandos externos o crear procesos.

Nivel de riesgo: Crítico

Ejemplos: - subprocess.run() en Python - child_process.exec() en Node.js - os.system() en Python - Ejecución de comandos shell

Sub-permisos: - Listas de comandos permitidos específicos - Acceso a shell (restringido vs sin restricciones)

3.2 Eval (`eval`)¶

Descripción: Capacidad de evaluar o compilar código dinámicamente en tiempo de ejecución.

Nivel de riesgo: Crítico

Ejemplos: - eval() en Python/JavaScript - exec() en Python - Constructor Function() en JavaScript - compile() en Python

Nota: Este es un permiso booleano (presente o ausente).

3.3 Filesystem (`filesystem`)¶

Descripción: Capacidad de leer, escribir o eliminar archivos en el sistema de archivos local.

Nivel de riesgo: Alto a Crítico (dependiendo del alcance)

Operaciones: - Read: Acceso para leer contenidos de archivos - Write: Capacidad de crear o modificar archivos - Delete: Capacidad de eliminar archivos o directorios

Ejemplos: - open(), Path.read_text() en Python - fs.readFileSync(), fs.writeFileSync() en Node.js - shutil.rmtree() en Python

3.4 Network (`network`)¶

Descripción: Capacidad de realizar conexiones de red salientes.

Nivel de riesgo: Alto

Atributos: - Hosts/dominios destino - Protocolos (HTTP, HTTPS, WebSocket, TCP raw) - Puertos

Ejemplos: - requests.get(), httpx.post() en Python - fetch(), axios en JavaScript - Operaciones de socket

3.5 Database (`database`)¶

Descripción: Capacidad de conectarse y consultar bases de datos.

Nivel de riesgo: Alto

Atributos: - Tipo de base de datos (SQLite, PostgreSQL, MySQL, MongoDB, Redis) - Flag de acceso de escritura

Ejemplos: - sqlite3.connect() en Python - Conexiones psycopg2, pymongo - Operaciones ORM (SQLAlchemy, Prisma)

3.6 Secrets (`secrets`)¶

Descripción: Acceso a credenciales sensibles, tokens o claves API.

Nivel de riesgo: Crítico

Atributos: - Nombre/identificador del secreto - Tipo de secreto (api_key, token, password, certificate) - Riesgo de exposición (logueado, transmitido, almacenado)

Ejemplos: - Lectura de archivos .env - Acceso a almacenes de credenciales - Variables de entorno con nombres sensibles

3.7 LLM (`llm`)¶

Descripción: Integración con APIs de Modelos de Lenguaje Grande.

Nivel de riesgo: Medio a Alto

Proveedores: - OpenAI - Anthropic - Google (Gemini) - Ollama (local) - Cohere - Hugging Face - LangChain (framework) - LlamaIndex (framework)

Ejemplos: - openai.ChatCompletion.create() - anthropic.messages.create() - Cadenas y agentes de LangChain

3.8 Env (`env`)¶

Descripción: Acceso a variables de entorno.

Nivel de riesgo: Bajo a Alto (dependiendo de la variable)

Atributos: - Nombre de la variable - Flag de sensibilidad (variables sensibles como claves API) - Flag de acceso de escritura

Ejemplos: - os.environ.get() en Python - process.env en Node.js - os.Getenv() en Go

4. Modelo de Datos¶

4.1 InferredPermissions¶

La estructura raíz que contiene todos los permisos detectados.

InferredPermissions {
    version: string           // Versión de la especificación (ej: "1.0.0")
    exec: ExecPermission?     // Permisos de ejecución de comandos
    eval: boolean             // Evaluación dinámica de código
    filesystem: FilesystemPermission?
    network: NetworkPermission?
    database: DatabasePermission?
    secrets: SecretsPermission?
    llm: LLMPermission?
    env: EnvPermission?
    summary: PermissionSummary
}

4.2 ExecPermission¶

ExecPermission {
    commands: CommandPermission[]  // Comandos específicos detectados
    shell: boolean                 // Acceso a shell sin restricciones
}

CommandPermission {
    command: string           // Nombre o patrón del comando
    dangerous: boolean        // Flag de comando de alto riesgo
    confidence: Confidence
    location: string          // Ubicación en código (archivo:línea)
}

Comandos peligrosos incluyen: rm, chmod, chown, kill, mkfs, dd, curl|sh, wget|sh

4.3 FilesystemPermission¶

FilesystemPermission {
    read: PathPattern[]       // Patrones de acceso de lectura
    write: PathPattern[]      // Patrones de acceso de escritura
    delete: PathPattern[]     // Patrones de acceso de eliminación
}

PathPattern {
    pattern: string           // Ruta o patrón glob
    confidence: Confidence
    location: string
}

4.4 NetworkPermission¶

NetworkPermission {
    outbound: HostPermission[]  // Destinos de conexiones salientes
    inbound: HostPermission[]   // Listeners entrantes (raro)
}

HostPermission {
    host: string              // Hostname, IP, o "*" para cualquiera
    protocol: Protocol        // http, https, ws, wss, tcp, udp
    port: integer?            // Puerto específico o null para cualquiera
    confidence: Confidence
    location: string
}

Protocol: "http" | "https" | "ws" | "wss" | "tcp" | "udp" | "unknown"

4.5 DatabasePermission¶

DatabasePermission {
    connections: DatabaseConnection[]
}

DatabaseConnection {
    database_type: DatabaseType
    write_access: boolean     // Puede modificar datos
    confidence: Confidence
    location: string
}

DatabaseType: "sqlite" | "postgresql" | "mysql" | "mongodb" |
              "redis" | "elasticsearch" | "unknown"

4.6 SecretsPermission¶

SecretsPermission {
    accessed: SecretAccess[]
}

SecretAccess {
    name: string              // Identificador del secreto
    secret_type: SecretType   // Clasificación
    exposed: boolean          // Potencialmente logueado/transmitido
    confidence: Confidence
    location: string
}

SecretType: "api_key" | "token" | "password" | "certificate" |
            "connection_string" | "unknown"

4.7 LLMPermission¶

LLMPermission {
    providers: LLMProviderAccess[]
}

LLMProviderAccess {
    provider: LLMProvider
    confidence: Confidence
    location: string
}

LLMProvider: "openai" | "anthropic" | "google" | "ollama" |
             "cohere" | "huggingface" | "langchain" | "llamaindex" | "unknown"

4.8 EnvPermission¶

EnvPermission {
    accessed: EnvVarAccess[]
}

EnvVarAccess {
    name: string              // Nombre de la variable
    sensitive: boolean        // Contiene datos sensibles
    write: boolean            // Modifica la variable
    confidence: Confidence
    location: string
}

4.9 PermissionSummary¶

PermissionSummary {
    total_permissions: integer      // Conteo total
    by_category: map<Category, int> // Conteo por categoría
    high_risk_count: integer        // Items de riesgo crítico/alto
    findings_analyzed: integer      // Conteo de hallazgos origen
}

4.10 Niveles de Confianza¶

Confidence: "high" | "medium" | "low"

Nivel	Descripción	Origen típico
high	Llamada directa a API detectada	Match de patrón en función conocida
medium	Match indirecto o parcial	Inferido de imports o contexto
low	Detección heurística	Análisis de strings o patrones de nombres

5. Algoritmo de Inferencia¶

5.1 Visión General¶

El proceso de inferencia transforma hallazgos de seguridad en permisos estructurados:

Findings[] → ClasificadorCategoría → Extractor → InferredPermissions

5.2 Clasificación de Categorías¶

Cada hallazgo se clasifica analizando su ID de regla y categoría de sink:

Patrón de Rule ID	Categoría
`subprocess`, `os.system`, `child_process`, `spawn`, `popen`, `MCP-A*`	exec
`eval`, `exec` (sin subprocess), `compile`, `Function`	eval
`file`, `path`, `open` (no openai), `write`, `read`, `unlink`, `shutil`, `MCP-B*`	filesystem
`http`, `fetch`, `request`, `axios`, `urllib`, `socket`, `ssrf`, `MCP-C*`	network
`sql`, `database`, `query`, `cursor`, `sqlite`, `postgres`, `mongo`, `MCP-D*`	database
`secret`, `token`, `credential`, `password`, `api_key`, `MCP-E*`	secrets
`llm`, `openai`, `anthropic`, `claude`, `gpt`, `langchain`	llm
`env`, `environ`, `getenv`, `process.env`	env

5.3 Extracción de Detalles¶

Después de la clasificación, se extraen detalles específicos del hallazgo:

5.3.1 Extracción de Comandos (exec)¶

Entrada: "subprocess.run(['ls', '-la', path])"
Salida: command="ls", dangerous=false

Patrones de extracción: 1. Primer argumento de funciones exec 2. Literales de string en arrays de comandos 3. Strings de comandos shell

5.3.2 Extracción de Rutas (filesystem)¶

Entrada: "open('/etc/passwd', 'r')"
Salida: pattern="/etc/*", operation=read

Detección de operaciones: - Read: 'r', 'rb', read, readFile - Write: 'w', 'a', 'wb', write, writeFile - Delete: unlink, remove, rmtree, rmdir

5.3.3 Extracción de Hosts (network)¶

Entrada: "requests.get('https://api.example.com/data')"
Salida: host="api.example.com", protocol="https"

Regex de extracción: https?://([a-zA-Z0-9][-a-zA-Z0-9.]*)

5.3.4 Detección de Proveedor LLM¶

Entrada: Rule ID "py-openai-llm-chat", snippet "openai.ChatCompletion"
Salida: provider="openai"

Patrones de proveedores: | Patrón | Proveedor | |--------|-----------| | openai, gpt | openai | | anthropic, claude | anthropic | | ollama | ollama | | langchain | langchain | | llamaindex, llama_index | llamaindex |

5.4 Deduplicación¶

Los permisos se deduplican por: 1. Misma categoría 2. Mismo objetivo (comando, ruta, host, etc.) 3. Mayor confianza reemplaza menor confianza

6. Comparación de Permisos¶

6.1 Propósito¶

La comparación valida que los permisos declarados coincidan con el comportamiento real del código.

6.2 Resultado de Comparación¶

ComparisonResult {
    matches: PermissionMatch[]        // Declarados y encontrados en código
    undeclared: UndeclaredPermission[] // Encontrados pero no declarados
    overdeclared: OverdeclaredPermission[] // Declarados pero no encontrados
    risk_level: RiskLevel
    summary: string
}

6.3 Tipos de Coincidencia¶

6.3.1 Permiso Coincidente¶

Un permiso declarado que fue confirmado por análisis de código.

PermissionMatch {
    category: Category
    declared: string    // Del manifiesto
    inferred: string    // Del código
    confidence: Confidence
}

6.3.2 Permiso No Declarado¶

Un permiso detectado en código pero no declarado en el manifiesto.

Implicación de seguridad: El servidor MCP usa capacidades que no reveló.

UndeclaredPermission {
    category: Category
    permission: string
    risk_level: RiskLevel
    location: string
    recommendation: string
}

6.3.3 Permiso Sobredeclarado¶

Un permiso declarado pero no detectado en código.

Causas posibles: - Código muerto - Comportamiento dinámico/runtime no detectado - Declaración demasiado amplia

OverdeclaredPermission {
    category: Category
    declared: string
    possible_reasons: string[]
}

7. Evaluación de Riesgo¶

7.1 Niveles de Riesgo¶

RiskLevel: "low" | "medium" | "high" | "critical"

7.2 Clasificación de Riesgo por Categoría¶

Categoría	Riesgo Base	Condiciones Críticas
exec	Crítico	Siempre crítico
eval	Crítico	Siempre crítico
filesystem	Alto	Write/delete a rutas del sistema
network	Alto	Hosts comodín
database	Alto	Acceso de escritura
secrets	Crítico	Secretos expuestos
llm	Medio	Múltiples proveedores
env	Bajo-Medio	Variables sensibles

7.3 Reglas de Escalamiento de Riesgo¶

El nivel de riesgo general es el máximo de:

Cualquier exec o eval no declarado → Crítico
Cualquier secrets no declarado con exposed=true → Crítico
Cualquier filesystem delete no declarado → Crítico
Cualquier network no declarado con host="*" → Alto
Múltiples permisos no declarados → Escalar un nivel
Solo permisos sobredeclarados → Bajo

7.4 Cálculo del Score de Riesgo¶

risk_score = sum(peso_categoria * conteo_permisos * multiplicador_confianza)

pesos_categoria = {
    exec: 10,
    eval: 10,
    secrets: 8,
    filesystem: 6,
    network: 5,
    database: 5,
    llm: 3,
    env: 2
}

multiplicador_confianza = {
    high: 1.0,
    medium: 0.7,
    low: 0.4
}

8. Esquema JSON¶

8.1 Esquema Completo¶

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "MCP Inferred Permissions",
  "type": "object",
  "properties": {
    "version": {
      "type": "string",
      "pattern": "^\\d+\\.\\d+\\.\\d+$"
    },
    "exec": {
      "$ref": "#/$defs/ExecPermission"
    },
    "eval": {
      "type": "boolean"
    },
    "filesystem": {
      "$ref": "#/$defs/FilesystemPermission"
    },
    "network": {
      "$ref": "#/$defs/NetworkPermission"
    },
    "database": {
      "$ref": "#/$defs/DatabasePermission"
    },
    "secrets": {
      "$ref": "#/$defs/SecretsPermission"
    },
    "llm": {
      "$ref": "#/$defs/LLMPermission"
    },
    "env": {
      "$ref": "#/$defs/EnvPermission"
    },
    "summary": {
      "$ref": "#/$defs/PermissionSummary"
    }
  },
  "required": ["version", "summary"],
  "$defs": {
    "Confidence": {
      "type": "string",
      "enum": ["high", "medium", "low"]
    },
    "ExecPermission": {
      "type": "object",
      "properties": {
        "commands": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "command": { "type": "string" },
              "dangerous": { "type": "boolean" },
              "confidence": { "$ref": "#/$defs/Confidence" },
              "location": { "type": "string" }
            },
            "required": ["command", "dangerous", "confidence", "location"]
          }
        },
        "shell": { "type": "boolean" }
      }
    },
    "FilesystemPermission": {
      "type": "object",
      "properties": {
        "read": { "type": "array", "items": { "$ref": "#/$defs/PathPattern" } },
        "write": { "type": "array", "items": { "$ref": "#/$defs/PathPattern" } },
        "delete": { "type": "array", "items": { "$ref": "#/$defs/PathPattern" } }
      }
    },
    "PathPattern": {
      "type": "object",
      "properties": {
        "pattern": { "type": "string" },
        "confidence": { "$ref": "#/$defs/Confidence" },
        "location": { "type": "string" }
      },
      "required": ["pattern", "confidence", "location"]
    },
    "NetworkPermission": {
      "type": "object",
      "properties": {
        "outbound": { "type": "array", "items": { "$ref": "#/$defs/HostPermission" } },
        "inbound": { "type": "array", "items": { "$ref": "#/$defs/HostPermission" } }
      }
    },
    "HostPermission": {
      "type": "object",
      "properties": {
        "host": { "type": "string" },
        "protocol": {
          "type": "string",
          "enum": ["http", "https", "ws", "wss", "tcp", "udp", "unknown"]
        },
        "port": { "type": ["integer", "null"] },
        "confidence": { "$ref": "#/$defs/Confidence" },
        "location": { "type": "string" }
      },
      "required": ["host", "protocol", "confidence", "location"]
    },
    "DatabasePermission": {
      "type": "object",
      "properties": {
        "connections": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "database_type": {
                "type": "string",
                "enum": ["sqlite", "postgresql", "mysql", "mongodb", "redis", "elasticsearch", "unknown"]
              },
              "write_access": { "type": "boolean" },
              "confidence": { "$ref": "#/$defs/Confidence" },
              "location": { "type": "string" }
            },
            "required": ["database_type", "write_access", "confidence", "location"]
          }
        }
      }
    },
    "SecretsPermission": {
      "type": "object",
      "properties": {
        "accessed": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "name": { "type": "string" },
              "secret_type": {
                "type": "string",
                "enum": ["api_key", "token", "password", "certificate", "connection_string", "unknown"]
              },
              "exposed": { "type": "boolean" },
              "confidence": { "$ref": "#/$defs/Confidence" },
              "location": { "type": "string" }
            },
            "required": ["name", "secret_type", "exposed", "confidence", "location"]
          }
        }
      }
    },
    "LLMPermission": {
      "type": "object",
      "properties": {
        "providers": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "provider": {
                "type": "string",
                "enum": ["openai", "anthropic", "google", "ollama", "cohere", "huggingface", "langchain", "llamaindex", "unknown"]
              },
              "confidence": { "$ref": "#/$defs/Confidence" },
              "location": { "type": "string" }
            },
            "required": ["provider", "confidence", "location"]
          }
        }
      }
    },
    "EnvPermission": {
      "type": "object",
      "properties": {
        "accessed": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "name": { "type": "string" },
              "sensitive": { "type": "boolean" },
              "write": { "type": "boolean" },
              "confidence": { "$ref": "#/$defs/Confidence" },
              "location": { "type": "string" }
            },
            "required": ["name", "sensitive", "write", "confidence", "location"]
          }
        }
      }
    },
    "PermissionSummary": {
      "type": "object",
      "properties": {
        "total_permissions": { "type": "integer", "minimum": 0 },
        "by_category": {
          "type": "object",
          "additionalProperties": { "type": "integer" }
        },
        "high_risk_count": { "type": "integer", "minimum": 0 },
        "findings_analyzed": { "type": "integer", "minimum": 0 }
      },
      "required": ["total_permissions", "by_category", "high_risk_count", "findings_analyzed"]
    }
  }
}

9. Ejemplos¶

9.1 Servidor MCP Básico con Múltiples Permisos¶

Código fuente (Python):

import subprocess
import requests
import openai
import os

def execute_command(cmd):
    return subprocess.run(cmd, shell=True, capture_output=True)

def fetch_data(url):
    return requests.get(url)

def ask_llm(prompt):
    api_key = os.environ.get("OPENAI_API_KEY")
    return openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )

Permisos inferidos:

href="#__codelineno-23-1">{ "version": "1.0.0", "exec": { "commands": [ { "command": "*", "dangerous": true, "confidence": "high", "location": "server.py:7" } ], "shell": true }, "network": { "outbound": [ { "host": "*", "protocol": "https", "port": null, "confidence": "high", "location": "server.py:10" } ] }, "llm": { "providers": [ { "provider": "openai", "confidence": "high", "location": "server.py:14" } ] }, "env": { "accessed": [ { "name": "OPENAI_API_KEY", "sensitive": true, "write": false, "confidence": "high", "location": "server.py:13" } ] }, "summary": { "total_permissions": 4, "by_category": { "exec": 1, "network": 1, "llm": 1, "env": 1 }, "high_risk_count": 2, "findings_analyzed": 4 } }

9.2 Operaciones de Sistema de Archivos¶

Código fuente (TypeScript):

import * as fs from 'fs';
import * as path from 'path';

export function readConfig(configPath: string): string {
    return fs.readFileSync(configPath, 'utf-8');
}

export function writeOutput(data: string): void {
    fs.writeFileSync('/tmp/output.txt', data);
}

export function cleanup(dir: string): void {
    fs.rmSync(dir, { recursive: true });
}

Permisos inferidos:

{
  "version": "1.0.0",
  "filesystem": {
    "read": [
      {
        "pattern": "*",
        "confidence": "high",
        "location": "files.ts:5"
      }
    ],
    "write": [
      {
        "pattern": "/tmp/*",
        "confidence": "high",
        "location": "files.ts:9"
      }
    ],
    "delete": [
      {
        "pattern": "*",
        "confidence": "high",
        "location": "files.ts:13"
      }
    ]
  },
  "summary": {
    "total_permissions": 3,
    "by_category": {
      "filesystem": 3
    },
    "high_risk_count": 1,
    "findings_analyzed": 3
  }
}

9.3 Resultado de Comparación de Permisos¶

Permisos declarados (manifiesto):

{
  "permissions": {
    "exec": ["ls", "cat"],
    "llm": ["openai"]
  }
}

Resultado de comparación:

{
  "matches": [
    {
      "category": "exec",
      "declared": "ls",
      "inferred": "ls",
      "confidence": "high"
    },
    {
      "category": "llm",
      "declared": "openai",
      "inferred": "openai",
      "confidence": "high"
    }
  ],
  "undeclared": [
    {
      "category": "exec",
      "permission": "rm",
      "risk_level": "critical",
      "location": "cleanup.py:15",
      "recommendation": "Añadir 'rm' a los permisos exec declarados o eliminar el código"
    },
    {
      "category": "llm",
      "permission": "anthropic",
      "risk_level": "medium",
      "location": "llm.py:28",
      "recommendation": "Añadir 'anthropic' a los permisos llm declarados"
    }
  ],
  "overdeclared": [
    {
      "category": "exec",
      "declared": "cat",
      "possible_reasons": [
        "El comando nunca se llama en el código analizado",
        "El comando puede llamarse dinámicamente en runtime",
        "Ruta de código muerta"
      ]
    }
  ],
  "risk_level": "critical",
  "summary": "2 coincidencias, 2 no declarados (1 crítico), 1 sobredeclarado"
}

10. Guías de Integración¶

10.1 Integración en Salida de Escaneo¶

El campo inferred_permissions aparece en la sección mcp_surface de los resultados de escaneo:

{
  "mcp_surface": {
    "tools": [...],
    "transport": "stdio",
    "inferred_permissions": {
      "version": "1.0.0",
      ...
    }
  },
  "findings": [...]
}

10.2 Integración CI/CD¶

Verificaciones recomendadas para pipelines CI/CD:

# Ejemplo de workflow de GitHub Actions
- name: Escanear Servidor MCP
  run: mcp-scan scan . --output json > scan-results.json

- name: Verificar Permisos Críticos
  run: |
    jq -e '.mcp_surface.inferred_permissions.exec.shell != true' scan-results.json
    jq -e '.mcp_surface.inferred_permissions.summary.high_risk_count < 3' scan-results.json

10.3 Aplicación de Políticas¶

Las organizaciones pueden definir políticas de permisos:

# Ejemplo de política
permission_policy:
  allowed_categories:
    - filesystem
    - network
    - llm
  denied_categories:
    - exec
    - eval
  max_risk_level: medium
  require_declaration: true

10.4 Formato de Declaración en Manifiesto¶

Formato recomendado para declarar permisos en el manifiesto:

{
  "mcp": {
    "name": "mi-servidor-mcp",
    "version": "1.0.0",
    "permissions": {
      "filesystem": {
        "read": ["/config/*"],
        "write": ["/tmp/*"]
      },
      "network": {
        "outbound": ["api.example.com"]
      },
      "llm": ["openai"],
      "env": ["OPENAI_API_KEY", "CONFIG_PATH"]
    }
  }
}

Apéndice A: Variables de Entorno Sensibles¶

Los siguientes patrones se consideran sensibles:

Patrón	Tipo
`_API_KEY`, `_APIKEY`	Clave API
`_SECRET`	Secreto
`*_TOKEN`	Token
`_PASSWORD`, `_PASSWD`	Contraseña
`_CREDENTIAL`	Credencial
`DATABASE_URL`, `_DB_`	Cadena de conexión
`AWS_`, `AZURE_`, `GCP_*`	Credenciales de nube
`PRIVATE_KEY`, `_PRIVATE_`	Clave privada

Apéndice B: Comandos Peligrosos¶

Comandos clasificados como peligrosos:

Comando	Riesgo	Razón
`rm`	Crítico	Eliminación de archivos
`chmod`	Alto	Modificación de permisos
`chown`	Alto	Modificación de propiedad
`kill`	Alto	Terminación de procesos
`mkfs`	Crítico	Formateo de sistema de archivos
`dd`	Crítico	Acceso raw a disco
`curl \\| sh`	Crítico	Ejecución remota de código
`wget \\| sh`	Crítico	Ejecución remota de código
`eval`	Crítico	Inyección de código
`sudo`	Crítico	Escalamiento de privilegios

Apéndice C: Historial de Versiones¶

Versión	Fecha	Cambios
1.0.0	2025-01-30	Especificación inicial

Especificación de Inferencia de Permisos MCP¶

Tabla de Contenidos¶

1. Introducción¶

1.1 Propósito¶

1.2 Alcance¶

1.3 Conformidad¶

2. Terminología¶

3. Categorías de Permisos¶

3.1 Exec (exec)¶

3.2 Eval (eval)¶

3.3 Filesystem (filesystem)¶

3.4 Network (network)¶

3.5 Database (database)¶

3.6 Secrets (secrets)¶

3.7 LLM (llm)¶

3.8 Env (env)¶

4. Modelo de Datos¶

4.1 InferredPermissions¶

4.2 ExecPermission¶

4.3 FilesystemPermission¶

4.4 NetworkPermission¶

4.5 DatabasePermission¶

4.6 SecretsPermission¶

4.7 LLMPermission¶

4.8 EnvPermission¶

4.9 PermissionSummary¶

4.10 Niveles de Confianza¶

5. Algoritmo de Inferencia¶

5.1 Visión General¶

5.2 Clasificación de Categorías¶

5.3 Extracción de Detalles¶

5.3.1 Extracción de Comandos (exec)¶

5.3.2 Extracción de Rutas (filesystem)¶

5.3.3 Extracción de Hosts (network)¶

5.3.4 Detección de Proveedor LLM¶

5.4 Deduplicación¶

6. Comparación de Permisos¶

6.1 Propósito¶

6.2 Resultado de Comparación¶

6.3 Tipos de Coincidencia¶

6.3.1 Permiso Coincidente¶

6.3.2 Permiso No Declarado¶

6.3.3 Permiso Sobredeclarado¶

7. Evaluación de Riesgo¶

7.1 Niveles de Riesgo¶

7.2 Clasificación de Riesgo por Categoría¶

7.3 Reglas de Escalamiento de Riesgo¶

7.4 Cálculo del Score de Riesgo¶

8. Esquema JSON¶

8.1 Esquema Completo¶

9. Ejemplos¶

9.1 Servidor MCP Básico con Múltiples Permisos¶

9.2 Operaciones de Sistema de Archivos¶

9.3 Resultado de Comparación de Permisos¶

10. Guías de Integración¶

10.1 Integración en Salida de Escaneo¶

10.2 Integración CI/CD¶

10.3 Aplicación de Políticas¶

10.4 Formato de Declaración en Manifiesto¶

Apéndice A: Variables de Entorno Sensibles¶

Apéndice B: Comandos Peligrosos¶

Apéndice C: Historial de Versiones¶

3.1 Exec (`exec`)¶

3.2 Eval (`eval`)¶

3.3 Filesystem (`filesystem`)¶

3.4 Network (`network`)¶

3.5 Database (`database`)¶

3.6 Secrets (`secrets`)¶

3.7 LLM (`llm`)¶

3.8 Env (`env`)¶