Capacidades

Tauri proporciona a los desarrolladores de aplicaciones y plugins un sistema de capacidades para habilitar y restringir de forma granular la exposición del núcleo al frontend de la aplicación que se ejecuta en el WebView del sistema.

Las capacidades definen qué permisos se conceden o deniegan para qué ventanas o webviews.

Las capacidades pueden afectar a múltiples ventanas y webviews y estas pueden ser referenciadas en múltiples capacidades.

Consejo de seguridad

Las ventanas y WebViews que forman parte de más de una capacidad combinan efectivamente los límites de seguridad y los permisos de todas las capacidades involucradas.

Los archivos de capacidad se definen como un archivo JSON o TOML dentro del directorio src-tauri/capabilities.

Es una buena práctica usar archivos individuales y solo referenciarlos por identificador en el tauri.conf.json, pero también es posible definirlos directamente en el campo capabilities.

Todas las capacidades dentro del directorio capabilities están habilitadas automáticamente de forma predeterminada. Una vez que las capacidades se habilitan explícitamente en el tauri.conf.json, solo se utilizan estas en la compilación de la aplicación.

Para obtener una referencia completa del esquema de configuración, consulta la sección de referencias.

El siguiente JSON de ejemplo define una capacidad que permite que la ventana principal use la funcionalidad predeterminada de los plugins principales y la API window.setTitle.

src-tauri/capabilities/default.json

{
  "$schema": "../gen/schemas/desktop-schema.json",
  "identifier": "main-capability",
  "description": "Capability for the main window",
  "windows": ["main"],
  "permissions": [
    "core:path:default",
    "core:event:default",
    "core:window:default",
    "core:app:default",
    "core:resources:default",
    "core:menu:default",
    "core:tray:default",
    "core:window:allow-set-title"
  ]
}

Estos fragmentos forman parte del archivo de configuración de Tauri.

Este es probablemente el método de configuración más común, donde las capacidades individuales están integradas en línea y solo se hace referencia a los permisos por su identificador.

Esto requiere archivos de capacidad bien definidos en el directorio capabilities.

src-tauri/tauri.conf.json

{
  "app": {
    "security": {
      "capabilities": ["my-capability", "main-capability"]
    }
  }
}

Las capacidades integradas (inline) se pueden combinar con capacidades predefinidas.

src-tauri/tauri.conf.json

{
  "app": {
    "security": {
      "capabilities": [
        {
          "identifier": "my-capability",
          "description": "My application capability used for all windows",
          "windows": ["*"],
          "permissions": ["fs:default", "allow-home-read-extended"]
        },
        "my-second-capability"
      ]
    }
  }
}

De forma predeterminada, todos los comandos que hayas registrado en tu aplicación (usando la función tauri::Builder::invoke_handler) tienen permitido ser usados por todas las ventanas y webviews de la aplicación. Para cambiar eso, considera usar AppManifest::commands.

src-tauri/build.rs

fn main() {
    tauri_build::try_build(
        tauri_build::Attributes::new()
            .app_manifest(tauri_build::AppManifest::new().commands(&["your_command"])),
    )
    .unwrap();
}

Plataforma de destino

Las capacidades pueden ser específicas de una plataforma definiendo el array platforms. Por defecto la capacidad se aplica a todos los destinos, pero puedes seleccionar un subconjunto de los destinos linux, macOS, windows, iOS y android.

Por ejemplo, una capacidad para sistemas operativos de escritorio. Nota que habilita permisos en plugins que solo están disponibles en escritorio:

src-tauri/capabilities/desktop.json

{
  "$schema": "../gen/schemas/desktop-schema.json",
  "identifier": "desktop-capability",
  "windows": ["main"],
  "platforms": ["linux", "macOS", "windows"],
  "permissions": ["global-shortcut:allow-register"]
}

Y otro ejemplo de una capacidad para dispositivos móviles. Nota que habilita permisos en plugins que solo están disponibles en móviles:

src-tauri/capabilities/mobile.json

{
  "$schema": "../gen/schemas/mobile-schema.json",
  "identifier": "mobile-capability",
  "windows": ["main"],
  "platforms": ["iOS", "android"],
  "permissions": [
    "nfc:allow-scan",
    "biometric:allow-authenticate",
    "barcode-scanner:allow-scan"
  ]
}

Acceso remoto a la API

De forma predeterminada, la API solo es accesible para el código empaquetado que se incluye con la aplicación Tauri. Para permitir que fuentes remotas accedan a ciertos comandos de Tauri, es posible definirlo en el archivo de configuración de capacidad.

Este ejemplo permitiría escanear etiquetas NFC y usar el escáner de códigos de barras desde todos los subdominios de tauri.app.

src-tauri/capabilities/remote-tags.json

{
  "$schema": "../gen/schemas/remote-schema.json",
  "identifier": "remote-tag-capability",
  "windows": ["main"],
  "remote": {
    "urls": ["https://*.tauri.app"]
  },
  "platforms": ["iOS", "android"],
  "permissions": ["nfc:allow-scan", "barcode-scanner:allow-scan"]
}

Precaución

En Linux y Android, Tauri no puede distinguir entre las solicitudes provenientes de un <iframe> incrustado y la ventana misma.

Por favor, considera muy detenidamente el uso de esta función y lee más sobre las implicaciones de seguridad específicas para tu sistema operativo de destino en la sección de referencia de esta función.

Límites de seguridad

¿Contra qué protege?

Dependiendo de los permisos y capacidades, puede:

• Minimizar el impacto del compromiso del frontend
• Prevenir o reducir la exposición (accidental) de datos e interfaces locales del sistema
• Prevenir o reducir una posible escalada de privilegios del frontend al backend/sistema

What does it not protect against?

• Código de Rust malicioso o inseguro
• Alcances y configuración demasiado laxos
• Comprobaciones de alcance incorrectas en la implementación del comando
• Bypass intencionales desde el código de Rust
• Básicamente cualquier cosa que se haya escrito en el núcleo de Rust de una aplicación
• Vulnerabilidades de día cero (0-days) o de día uno no parcheadas (1-days) en el sistema WebView
• Ataques a la cadena de suministro o sistemas de desarrollador comprometidos de otro modo

Consejo de seguridad

Los límites de seguridad dependen de las etiquetas de ventana (no de los títulos). Recomendamos exponer únicamente la funcionalidad de creación de ventanas a ventanas con mayores privilegios.

Archivos de esquema

Tauri genera esquemas JSON con todos los permisos disponibles para tu aplicación a través de tauri-build, lo que permite el autocompletado en tu IDE. Para usar un esquema, establece la propiedad $schema en tu archivo de configuración (ya sea .json o .toml) apuntando a uno de los esquemas específicos de la plataforma ubicados en el directorio gen/schemas. Por lo general, lo establecerás en ../gen/schemas/desktop-schema.json o ../gen/schemas/mobile-schema.json, aunque también puedes definir una capacidad para una plataforma de destino específica.

Archivos de configuración

Ejemplo simplificado de la estructura de directorios de una aplicación Tauri de ejemplo:

tauri-app
├── index.html
├── package.json
├── src/
├── src-tauri/
│   ├── Cargo.toml
│   ├── capabilities/
│   │  └── <identifier>.json/toml
│   ├── src/
│   ├── tauri.conf.json

Todo se puede integrar en línea en el tauri.conf.json, pero incluso una configuración un poco más avanzada inflaría este archivo, y el objetivo de este enfoque es que los permisos estén abstraídos siempre que sea posible y sean sencillos de entender.

Core Permissions

Se puede encontrar una lista de todos los permisos principales en la página de Permisos principales.