2019-01-21 14:03:30 -05:00
|
|
|
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
|
2019-01-14 01:30:38 -05:00
|
|
|
use atty;
|
2018-10-27 09:11:39 -04:00
|
|
|
|
2019-01-14 01:30:38 -05:00
|
|
|
use crate::flags::DenoFlags;
|
2018-10-27 09:11:39 -04:00
|
|
|
|
2019-02-07 16:19:50 -05:00
|
|
|
use ansi_term::Style;
|
2019-01-14 01:30:38 -05:00
|
|
|
use crate::errors::permission_denied;
|
|
|
|
use crate::errors::DenoResult;
|
2018-10-27 09:11:39 -04:00
|
|
|
use std::io;
|
2018-11-29 22:03:00 -05:00
|
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
2018-10-27 09:11:39 -04:00
|
|
|
|
2018-11-05 01:21:21 -05:00
|
|
|
#[cfg_attr(feature = "cargo-clippy", allow(stutter))]
|
2018-11-29 22:03:00 -05:00
|
|
|
#[derive(Debug, Default)]
|
2018-10-27 09:11:39 -04:00
|
|
|
pub struct DenoPermissions {
|
2019-02-08 15:59:38 -05:00
|
|
|
pub allow_read: AtomicBool,
|
2018-11-29 22:03:00 -05:00
|
|
|
pub allow_write: AtomicBool,
|
|
|
|
pub allow_net: AtomicBool,
|
|
|
|
pub allow_env: AtomicBool,
|
|
|
|
pub allow_run: AtomicBool,
|
2018-10-27 09:11:39 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
impl DenoPermissions {
|
2018-11-05 01:21:21 -05:00
|
|
|
pub fn new(flags: &DenoFlags) -> Self {
|
|
|
|
Self {
|
2019-02-08 15:59:38 -05:00
|
|
|
allow_read: AtomicBool::new(flags.allow_read),
|
2018-11-29 22:03:00 -05:00
|
|
|
allow_write: AtomicBool::new(flags.allow_write),
|
|
|
|
allow_env: AtomicBool::new(flags.allow_env),
|
|
|
|
allow_net: AtomicBool::new(flags.allow_net),
|
|
|
|
allow_run: AtomicBool::new(flags.allow_run),
|
2018-10-27 09:11:39 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-29 22:03:00 -05:00
|
|
|
pub fn check_run(&self) -> DenoResult<()> {
|
|
|
|
if self.allow_run.load(Ordering::SeqCst) {
|
2018-11-15 23:07:40 -05:00
|
|
|
return Ok(());
|
|
|
|
};
|
|
|
|
// TODO get location (where access occurred)
|
2019-02-07 16:19:50 -05:00
|
|
|
let r = permission_prompt("access to run a subprocess");
|
2018-11-15 23:07:40 -05:00
|
|
|
if r.is_ok() {
|
2018-11-29 22:03:00 -05:00
|
|
|
self.allow_run.store(true, Ordering::SeqCst);
|
2018-11-15 23:07:40 -05:00
|
|
|
}
|
|
|
|
r
|
|
|
|
}
|
|
|
|
|
2019-02-08 15:59:38 -05:00
|
|
|
pub fn check_read(&self, filename: &str) -> DenoResult<()> {
|
|
|
|
if self.allow_read.load(Ordering::SeqCst) {
|
|
|
|
return Ok(());
|
|
|
|
};
|
|
|
|
// TODO get location (where access occurred)
|
2019-02-09 05:30:01 -05:00
|
|
|
let r = permission_prompt(&format!("read access to \"{}\"", filename));;
|
2019-02-08 15:59:38 -05:00
|
|
|
if r.is_ok() {
|
|
|
|
self.allow_read.store(true, Ordering::SeqCst);
|
|
|
|
}
|
|
|
|
r
|
|
|
|
}
|
|
|
|
|
2018-11-29 22:03:00 -05:00
|
|
|
pub fn check_write(&self, filename: &str) -> DenoResult<()> {
|
|
|
|
if self.allow_write.load(Ordering::SeqCst) {
|
2018-10-27 09:11:39 -04:00
|
|
|
return Ok(());
|
|
|
|
};
|
|
|
|
// TODO get location (where access occurred)
|
2019-02-07 16:19:50 -05:00
|
|
|
let r = permission_prompt(&format!("write access to \"{}\"", filename));;
|
2018-10-27 09:11:39 -04:00
|
|
|
if r.is_ok() {
|
2018-11-29 22:03:00 -05:00
|
|
|
self.allow_write.store(true, Ordering::SeqCst);
|
2018-10-27 09:11:39 -04:00
|
|
|
}
|
|
|
|
r
|
|
|
|
}
|
|
|
|
|
2018-11-29 22:03:00 -05:00
|
|
|
pub fn check_net(&self, domain_name: &str) -> DenoResult<()> {
|
|
|
|
if self.allow_net.load(Ordering::SeqCst) {
|
2018-10-27 09:11:39 -04:00
|
|
|
return Ok(());
|
|
|
|
};
|
|
|
|
// TODO get location (where access occurred)
|
2019-02-07 16:19:50 -05:00
|
|
|
let r =
|
|
|
|
permission_prompt(&format!("network access to \"{}\"", domain_name));
|
2018-10-27 09:11:39 -04:00
|
|
|
if r.is_ok() {
|
2018-11-29 22:03:00 -05:00
|
|
|
self.allow_net.store(true, Ordering::SeqCst);
|
2018-10-27 09:11:39 -04:00
|
|
|
}
|
|
|
|
r
|
|
|
|
}
|
|
|
|
|
2018-11-29 22:03:00 -05:00
|
|
|
pub fn check_env(&self) -> DenoResult<()> {
|
|
|
|
if self.allow_env.load(Ordering::SeqCst) {
|
2018-10-27 09:11:39 -04:00
|
|
|
return Ok(());
|
|
|
|
};
|
|
|
|
// TODO get location (where access occurred)
|
2019-02-07 16:19:50 -05:00
|
|
|
let r = permission_prompt(&"access to environment variables");
|
2018-10-27 09:11:39 -04:00
|
|
|
if r.is_ok() {
|
2018-11-29 22:03:00 -05:00
|
|
|
self.allow_env.store(true, Ordering::SeqCst);
|
2018-10-27 09:11:39 -04:00
|
|
|
}
|
|
|
|
r
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-04 09:04:24 -05:00
|
|
|
fn permission_prompt(message: &str) -> DenoResult<()> {
|
2018-10-27 09:11:39 -04:00
|
|
|
if !atty::is(atty::Stream::Stdin) || !atty::is(atty::Stream::Stderr) {
|
|
|
|
return Err(permission_denied());
|
|
|
|
};
|
2019-02-07 16:19:50 -05:00
|
|
|
let msg = format!("⚠️ Deno requests {}. Grant? [yN] ", message);
|
2018-10-27 09:11:39 -04:00
|
|
|
// print to stderr so that if deno is > to a file this is still displayed.
|
2019-02-07 16:19:50 -05:00
|
|
|
eprint!("{}", Style::new().bold().paint(msg));
|
2018-10-27 09:11:39 -04:00
|
|
|
let mut input = String::new();
|
|
|
|
let stdin = io::stdin();
|
|
|
|
let _nread = stdin.read_line(&mut input)?;
|
|
|
|
let ch = input.chars().next().unwrap();
|
|
|
|
let is_yes = ch == 'y' || ch == 'Y';
|
|
|
|
if is_yes {
|
|
|
|
Ok(())
|
|
|
|
} else {
|
|
|
|
Err(permission_denied())
|
|
|
|
}
|
|
|
|
}
|