Allow inspection and revocation of permissions (#1875)

3 files changed, 116 insertions, 0 deletions

diff --git a/src/msg.fbs b/src/msg.fbs
index da03e00a4..1b57e72ef 100644
--- a/src/msg.fbs
+++ b/src/msg.fbs
@@ -12,6 +12,9 @@ union Any {
   Exit,
   Environ,
   EnvironRes,
+  Permissions,
+  PermissionRevoke,
+  PermissionsRes,
   Fetch,
   FetchRes,
   MakeTempDir,
@@ -231,6 +234,20 @@ table KeyValue {
   value: string;
 }
 
+table Permissions {}
+
+table PermissionRevoke {
+  permission: string;
+}
+
+table PermissionsRes {
+  run: bool;
+  read: bool;
+  write: bool;
+  net: bool;
+  env: bool;
+}
+
 // Note this represents The WHOLE header of an http message, not just the key
 // value pairs. That means it includes method and url for Requests and status
 // for responses. This is why it is singular "Header" instead of "Headers".
diff --git a/src/ops.rs b/src/ops.rs
index 5535ca1b9..ba309ca7a 100644
--- a/src/ops.rs
+++ b/src/ops.rs
@@ -130,6 +130,8 @@ pub fn dispatch(
       msg::Any::Now => op_now,
       msg::Any::IsTTY => op_is_tty,
       msg::Any::Seek => op_seek,
+      msg::Any::Permissions => op_permissions,
+      msg::Any::PermissionRevoke => op_revoke_permission,
       _ => panic!(format!(
         "Unhandled message {}",
         msg::enum_name_any(inner_type)
@@ -503,6 +505,57 @@ fn op_env(
   ))
 }
 
+fn op_permissions(
+  isolate: &Isolate,
+  base: &msg::Base<'_>,
+  data: libdeno::deno_buf,
+) -> Box<Op> {
+  assert_eq!(data.len(), 0);
+  let cmd_id = base.cmd_id();
+  let builder = &mut FlatBufferBuilder::new();
+  let inner = msg::PermissionsRes::create(
+    builder,
+    &msg::PermissionsResArgs {
+      run: isolate.permissions.allows_run(),
+      read: isolate.permissions.allows_read(),
+      write: isolate.permissions.allows_write(),
+      net: isolate.permissions.allows_net(),
+      env: isolate.permissions.allows_env(),
+    },
+  );
+  ok_future(serialize_response(
+    cmd_id,
+    builder,
+    msg::BaseArgs {
+      inner: Some(inner.as_union_value()),
+      inner_type: msg::Any::PermissionsRes,
+      ..Default::default()
+    },
+  ))
+}
+
+fn op_revoke_permission(
+  isolate: &Isolate,
+  base: &msg::Base<'_>,
+  data: libdeno::deno_buf,
+) -> Box<Op> {
+  assert_eq!(data.len(), 0);
+  let inner = base.inner_as_permission_revoke().unwrap();
+  let permission = inner.permission().unwrap();
+  let result = match permission {
+    "run" => isolate.permissions.revoke_run(),
+    "read" => isolate.permissions.revoke_read(),
+    "write" => isolate.permissions.revoke_write(),
+    "net" => isolate.permissions.revoke_net(),
+    "env" => isolate.permissions.revoke_env(),
+    _ => Ok(()),
+  };
+  if let Err(e) = result {
+    return odd_future(e);
+  }
+  ok_future(empty_buf())
+}
+
 fn op_fetch(
   isolate: &Isolate,
   base: &msg::Base<'_>,
diff --git a/src/permissions.rs b/src/permissions.rs
index b40afb64e..03ffd20cb 100644
--- a/src/permissions.rs
+++ b/src/permissions.rs
@@ -12,6 +12,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 #[cfg_attr(feature = "cargo-clippy", allow(stutter))]
 #[derive(Debug, Default)]
 pub struct DenoPermissions {
+  // Keep in sync with src/permissions.ts
   pub allow_read: AtomicBool,
   pub allow_write: AtomicBool,
   pub allow_net: AtomicBool,
@@ -91,6 +92,51 @@ impl DenoPermissions {
     r
   }
 
+  pub fn allows_run(&self) -> bool {
+    return self.allow_run.load(Ordering::SeqCst);
+  }
+
+  pub fn allows_read(&self) -> bool {
+    return self.allow_read.load(Ordering::SeqCst);
+  }
+
+  pub fn allows_write(&self) -> bool {
+    return self.allow_write.load(Ordering::SeqCst);
+  }
+
+  pub fn allows_net(&self) -> bool {
+    return self.allow_net.load(Ordering::SeqCst);
+  }
+
+  pub fn allows_env(&self) -> bool {
+    return self.allow_env.load(Ordering::SeqCst);
+  }
+
+  pub fn revoke_run(&self) -> DenoResult<()> {
+    self.allow_run.store(false, Ordering::SeqCst);
+    return Ok(());
+  }
+
+  pub fn revoke_read(&self) -> DenoResult<()> {
+    self.allow_read.store(false, Ordering::SeqCst);
+    return Ok(());
+  }
+
+  pub fn revoke_write(&self) -> DenoResult<()> {
+    self.allow_write.store(false, Ordering::SeqCst);
+    return Ok(());
+  }
+
+  pub fn revoke_net(&self) -> DenoResult<()> {
+    self.allow_net.store(false, Ordering::SeqCst);
+    return Ok(());
+  }
+
+  pub fn revoke_env(&self) -> DenoResult<()> {
+    self.allow_env.store(false, Ordering::SeqCst);
+    return Ok(());
+  }
+
   pub fn default() -> Self {
     Self {
       allow_read: AtomicBool::new(false),