权限、能力、作用域

pub struct Permission {
  /// The version of the permission.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub version: Option<NonZeroU64>,

  /// A unique identifier for the permission.
  pub identifier: String,

  /// Human-readable description of what the permission does.
  // ...
  pub description: Option<String>,

  /// Allowed or denied commands when using this permission.
  #[serde(default)]
  pub commands: Commands,

  /// Allowed or denied scoped when using this permission.
  #[serde(default, skip_serializing_if = "Scopes::is_empty")]
  pub scope: Scopes,

  /// Target platforms this permission applies. By default all platforms are affected by this permission.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub platforms: Option<Vec<Target>>,
}

[[permission]]
identifier = "allow-open-docs"
description = "open_doc under /docs, never /docs/private"
commands.allow = ["open_doc"]

[[permission.scope.allow]]
path = "/docs/*"

[[permission.scope.deny]]
path = "/docs/private/*"

[[permission]]
identifier = "allow-read-tmp"
description = "read under /tmp"
commands.allow = ["read"]

[[permission.scope.allow]]
path = "/tmp/*"

[[permission]]
identifier = "global-deny-secret"
description = "plugin-wide: never anything with secret in it"

[[permission.scope.deny]]
path = "*secret*"

fn main() {
  // `files` and `notes` live in their own crates (tauri-plugin-*), but their permissions
  // are declared here as inline plugins, so they don't need a build script or `links`.
  let attributes = tauri_build::Attributes::new()
    .app_manifest(tauri_build::AppManifest::new().commands(&["greet", "wipe", "open_doc"]))
    .plugin("files", tauri_build::InlinedPlugin::new().commands(&["read"]))
    .plugin("notes", tauri_build::InlinedPlugin::new().commands(&["read"]))
    .plugin("inline", tauri_build::InlinedPlugin::new().commands(&["read"]));
  tauri_build::try_build(attributes).expect("failed to run tauri-build");
}

{
  "identifier": "main",
  "windows": ["main"],
  "permissions": [
    "allow-greet",
    "allow-wipe",
    "allow-open-docs",
    "global-app",
    "files:allow-read-tmp",
    { "identifier": "files:allow-read", "allow": [{ "path": "/home/*" }] },
    "files:global-deny-secret",
    "notes:allow-read",
    "notes:global-allow-notes",
    "inline:allow-read"
  ]
}

{
  "identifier": "audit",
  "windows": ["audit"],
  "permissions": ["deny-wipe"]
}

  fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
    let mut init = urlpattern::UrlPatternInit::parse_constructor_string::<regex::Regex>(s, None)?;
    if init.search.as_ref().map(|p| p.is_empty()).unwrap_or(true) {
      init.search.replace("*".to_string());
    }
    if init.hash.as_ref().map(|p| p.is_empty()).unwrap_or(true) {
      init.hash.replace("*".to_string());
    }
    if init
      .pathname
      .as_ref()
      .map(|p| p.is_empty() || p == "/")
      .unwrap_or(true)
    {
      init.pathname.replace("*".to_string());
    }
    let pattern = urlpattern::UrlPattern::parse(init, Default::default())?;
    Ok(Self(Arc::new(pattern), s.to_string()))
  }

/// One scope entry, as written in the permission files: `{ path = "/docs/*" }`.
#[derive(Debug, Deserialize)]
pub struct Entry {
  pub path: String,
}

impl ScopeObjectMatch for Entry {
  type Input = str;
  fn matches(&self, input: &str) -> bool {
    glob::Pattern::new(&self.path).map(|p| p.matches(input)).unwrap_or(false)
  }
}

#[tauri::command]
fn open_doc(path: String, scope: CommandScope<Entry>) -> Result<String, String> {
  let verdict = scope.matches(&path);
  let s = format!(
    "allow={:?} deny={:?} matches({path})={verdict}",
    paths(scope.allows()),
    paths(scope.denies())
  );
  if verdict { Ok(s) } else { Err(s) }
}

[main @ tauri://localhost] open_doc -> Ok("allow=[\"/docs/*\"] deny=[\"/docs/private/*\"] matches(/docs/a.txt)=true")
[main @ tauri://localhost] open_doc -> Err:
    allow=["/docs/*"] deny=["/docs/private/*"] matches(/docs/private/key.txt)=false
[main @ tauri://localhost] open_doc -> Err:
    allow=["/docs/*"] deny=["/docs/private/*"] matches(/etc/passwd)=false

[main @ tauri://localhost] plugin:files|read -> Ok("command allow=[\"/tmp/*\", \"/home/*\"] deny=[]; global allow=[] deny=[\"*secret*\"]; ok=true")
[main @ tauri://localhost] plugin:files|read -> Ok("command allow=[\"/tmp/*\", \"/home/*\"] deny=[]; global allow=[] deny=[\"*secret*\"]; ok=false")