+ "parking_lot",

+ - [Workspace trust](./workspace-trust.md)

+| `:workspace-trust` | Add current workspace to the list of trusted workspaces. |

+| `:workspace-untrust` | Remove current workspace from the list of trusted workspaces. |

+# Workspace trust

+

+Helix has a number of potentially dangerous features, namely LSP and ability to use local to workspace configurations. Those features can lead to unexpected code execution. To protect against code execution in dangerous contexts, Helix has a workspace trust protection, which will prevent these potentially dangerous features from running automatically.

+

+Helix will not trust any workspace by default.

+

+By default, it will prompt about trust when you open new file in a workspace where you didn't make a decision about trust yet.

+

+If you decide not to trust a workspace and don't want to be prompted about trust every time you start a new session in it, you can exclude the workspace by choosing `Never` option in trust selection window.

+

+You can always make current workspace trusted by running `:workspace-trust` command, and untrust it with `:workspace-untrust`.

+

+Lists of trusted and excluded workspaces, delimited by newline characters, are stored in `~/.local/share/helix/trusted_workspaces` and `~/.local/share/helix/excluded_workspaces` correspondingly.

+<!-- TODO: Windows paths -->

+

+# Configuration

+

+You can return to the old behaviour of loading every local `.helix/config.toml` and `.helix/languages.toml` and starting LSP's without an explicit permission by setting following option:

+

+```toml

+[editor]

+insecure = true

+```

+pub fn user_lang_config(insecure: bool) -> Result<Configuration, toml::de::Error> {

+ helix_loader::config::user_lang_config(insecure)?.try_into()

+pub fn user_lang_loader(insecure: bool) -> Result<Loader, LanguageLoaderError> {

+ let config_val = helix_loader::config::user_lang_config(insecure)

+ .map_err(LanguageLoaderError::DeserializeError)?;

+use crate::workspace_trust::{quick_query_workspace, TrustStatus};

+

+pub fn user_lang_config(insecure: bool) -> Result<toml::Value, toml::de::Error> {

+ let global_config = crate::lang_config_file();

+ let workspace_config = crate::workspace_lang_config_file();

+

+ let files = if let TrustStatus::Trusted = quick_query_workspace(insecure) {

+ vec![global_config, workspace_config]

+ } else {

+ vec![global_config]

+ };

+

+ let config = files

+ .iter()

+ .filter_map(|file| {

+ std::fs::read_to_string(file)

+ .map(|config| toml::from_str(&config))

+ .ok()

+ })

+ .collect::<Result<Vec<_>, _>>()?

+ .into_iter()

+ .fold(default_lang_config(), |a, b| {

+ crate::merge_toml_values(a, b, 3)

+ });

+ let config: Configuration = crate::config::user_lang_config(false)

+ let config: Configuration = crate::config::user_lang_config(false)

+pub mod workspace_trust;

+pub fn data_dir() -> PathBuf {

+ let strategy = choose_base_strategy().expect("Unable to find the data directory!");

+ let mut path = strategy.data_dir();

+ path.push("helix");

+ path

+}

+

+pub fn workspace_lang_config_file() -> PathBuf {

+ find_workspace().0.join(".helix").join("languages.toml")

+}

+

+pub fn workspace_trust_file() -> PathBuf {

+ data_dir().join("trusted_workspaces")

+}

+

+pub fn workspace_exclude_file() -> PathBuf {

+ data_dir().join("excluded_workspaces")

+}

+

+use std::{collections::HashSet, fs, path::PathBuf};

+

+use crate::{data_dir, workspace_exclude_file, workspace_trust_file};

+

+pub struct WorkspaceTrust {

+ trusted: HashSet<PathBuf>,

+ excluded: Option<HashSet<PathBuf>>,

+}

+

+#[derive(Clone, Copy)]

+pub enum TrustStatus {

+ Untrusted,

+ Trusted,

+}

+

+impl WorkspaceTrust {

+ /// Loads `WorkspaceTrust`.

+ ///

+ /// Should be used only when there is a need to change trust status

+ /// of a particular workspace.

+ ///

+ /// For querying trust status of a workspace use `quick_query_workspace()` or

+ /// `quick_query_workspace_with_explicit_untrust()`

+ pub fn load(with_exclusion: bool) -> Self {

+ let mut trusted = HashSet::new();

+

+ match fs::read_to_string(workspace_trust_file()) {

+ Ok(workspace_trust_file) => {

+ for line in workspace_trust_file.split('\n') {

+ if !line.is_empty() {

+ let path = PathBuf::from(line);

+ trusted.insert(path);

+ }

+ }

+ }

+ Err(e) => log::error!("workspace file couldn't be read: {:?}", e),

+ };

+

+ let excluded = if with_exclusion {

+ let mut untrusted = HashSet::new();

+

+ match fs::read_to_string(workspace_exclude_file()) {

+ Ok(workspace_untrust_file) => {

+ for line in workspace_untrust_file.split('\n') {

+ if !line.is_empty() {

+ let path = PathBuf::from(line);

+ untrusted.insert(path);

+ }

+ }

+ }

+ Err(e) => log::error!("workspace file couldn't be read: {:?}", e),

+ };

+

+ Some(untrusted)

+ } else {

+ None

+ };

+ WorkspaceTrust { trusted, excluded }

+ }

+

+ fn write_trust_to_file(&self) {

+ let mut trust_text = String::new();

+ for workspace in self.trusted.iter() {

+ if let Some(path_str) = workspace.to_str() {

+ trust_text += &format!("{path_str}\n");

+ }

+ }

+ // let chains aren't supported in current MSRV

+ if let Ok(false) = fs::exists(data_dir()) {

+ if let Err(e) = fs::create_dir_all(data_dir()) {

+ log::error!("Couldn't create helix's data directory: {:?}", e);

+ };

+ }

+ if let Err(e) = fs::write(workspace_trust_file(), trust_text) {

+ log::error!("Error during write of workspace_trust file: {:?}", e);

+ }

+ }

+

+ fn write_exclusion_to_file(&self) {

+ if let Some(untrusted) = &self.excluded {

+ let mut trust_text = String::new();

+ for workspace in untrusted.iter() {

+ if let Some(path_str) = workspace.to_str() {

+ trust_text += &format!("{path_str}\n");

+ }

+ }

+ // let chains aren't supported in current MSRV

+ if let Ok(false) = fs::exists(data_dir()) {

+ if let Err(e) = fs::create_dir_all(data_dir()) {

+ log::error!("Couldn't create helix's data directory: {:?}", e);

+ };

+ }

+ if let Err(e) = fs::write(workspace_exclude_file(), trust_text) {

+ log::error!("Error during write of workspace_trust file: {:?}", e);

+ }

+ } else {

+ log::error!("Called write_untrust_to_file() when self.untrusted is None");

+ }

+ }

+

+ /// Mark current workspace trusted

+ pub fn trust_workspace(&mut self) {

+ let workspace = crate::find_workspace().0;

+ self.trusted.insert(workspace);

+ self.write_trust_to_file();

+ }

+

+ /// Remove trusted mark from current workspace

+ pub fn untrust_workspace(&mut self) {

+ let workspace = crate::find_workspace().0;

+ self.trusted.remove(&workspace);

+ self.write_trust_to_file();

+ }

+

+ /// Mark current workspace excluded.

+ ///

+ /// Should be called only if `WorkspaceTrust` was created with `WorkspaceTrust::load(true)`

+ pub fn exclude_workspace(&mut self) {

+ let workspace = crate::find_workspace().0;

+ self.trusted.remove(&workspace);

+ if let Some(excluded) = &mut self.excluded {

+ excluded.insert(workspace);

+ self.write_exclusion_to_file();

+ } else {

+ log::error!("Called untrust_workspace_permanent() when self.untrusted is None");

+ }

+ }

+}

+

+#[derive(Default, Clone, Copy, Debug)]

+pub enum TrustUntrustStatus {

+ DenyAlways,

+ #[default]

+ DenyOnce,

+ AllowAlways,

+}

+

+pub fn quick_query_workspace(insecure: bool) -> TrustStatus {

+ if insecure {

+ return TrustStatus::Trusted;

+ }

+

+ let workspace = crate::find_workspace().0;

+ match fs::read_to_string(workspace_trust_file()) {

+ Ok(workspace_trust_file) => {

+ for line in workspace_trust_file.split('\n') {

+ if PathBuf::from(line) == workspace {

+ return TrustStatus::Trusted;

+ }

+ }

+ }

+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => (),

+ Err(err) => log::error!("workspace file couldn't be read: {err:?}"),

+ };

+ TrustStatus::Untrusted

+}

+

+pub fn quick_query_workspace_with_explicit_untrust(insecure: bool) -> TrustUntrustStatus {

+ if insecure {

+ return TrustUntrustStatus::AllowAlways;

+ }

+

+ let workspace = crate::find_workspace().0;

+ match fs::read_to_string(workspace_trust_file()) {

+ Ok(workspace_trust_file) => {

+ for line in workspace_trust_file.split('\n') {

+ if PathBuf::from(line) == workspace {

+ return TrustUntrustStatus::AllowAlways;

+ }

+ }

+ }

+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => (),

+ Err(err) => log::error!("workspace_trust file couldn't be read: {err:?}"),

+ };

+

+ match fs::read_to_string(workspace_exclude_file()) {

+ Ok(workspace_untrust_file) => {

+ for line in workspace_untrust_file.split('\n') {

+ if PathBuf::from(line) == workspace {

+ return TrustUntrustStatus::DenyAlways;

+ }

+ }

+ }

+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => (),

+ Err(err) => log::error!("workspace_untrust file couldn't be read: {err:?}"),

+ };

+ TrustUntrustStatus::DenyOnce

+}

+parking_lot.workspace = true

+

+ let lang_loader = helix_core::config::user_lang_loader(default_config.editor.insecure)?;

+ TypableCommand {

+ name: "workspace-trust",

+ aliases: &[],

+ doc: "Add current workspace to the list of trusted workspaces.",

+ fun: trust_workspace,

+ completer: CommandCompleter::none(),

+ signature: Signature { positionals: (0, None), ..Signature::DEFAULT },

+ },

+ TypableCommand {

+ name: "workspace-untrust",

+ aliases: &[],

+ doc: "Remove current workspace from the list of trusted workspaces.",

+ fun: untrust_workspace,

+ completer: CommandCompleter::none(),

+ signature: Signature { positionals: (0, None), ..Signature::DEFAULT },

+ }

+

+fn trust_workspace(

+ cx: &mut compositor::Context,

+ args: Args<'_>,

+ event: PromptEvent,

+) -> anyhow::Result<()> {

+ if event != PromptEvent::Validate {

+ return Ok(());

+ }

+

+ helix_loader::workspace_trust::WorkspaceTrust::load(false).trust_workspace();

+

+ cx.editor.config_events.0.send(ConfigEvent::Refresh)?;

+ // HACK

+ lsp_restart(cx, args, event)

+}

+

+fn untrust_workspace(

+ _cx: &mut compositor::Context,

+ _args: Args<'_>,

+ event: PromptEvent,

+) -> anyhow::Result<()> {

+ if event != PromptEvent::Validate {

+ return Ok(());

+ }

+

+ helix_loader::workspace_trust::WorkspaceTrust::load(false).untrust_workspace();

+ Ok(())

+}

+ global: Result<&String, ConfigLoadError>,

+ global.and_then(|file| toml::from_str(file).map_err(ConfigLoadError::BadConfig));

+ fs::read_to_string(helix_loader::config_file()).map_err(ConfigLoadError::Error)?;

+

+ let phony_config = ConfigLoadError::Error(IOError::other("hacky placeholder"));

+ let global_parsed = Config::load(Ok(&global_config), Err(phony_config))?;

+ if let helix_loader::workspace_trust::TrustStatus::Trusted =

+ helix_loader::workspace_trust::quick_query_workspace(global_parsed.editor.insecure)

+ {

+ Config::load(Ok(&global_config), local_config)

+ } else {

+ Ok(global_parsed)

+ }

+ Config::load(Ok(&config.to_owned()), Err(ConfigLoadError::default())).unwrap()

+mod workspace_trust;

+ workspace_trust::register_hooks(&handlers);

+use std::{collections::HashSet, path::PathBuf};

+

+use helix_event::register_hook;

+use helix_loader::workspace_trust::{

+ quick_query_workspace_with_explicit_untrust, TrustUntrustStatus, WorkspaceTrust,

+};

+use helix_view::{events::DocumentDidOpen, handlers::Handlers, DocumentId};

+use once_cell::sync::Lazy;

+use parking_lot::Mutex;

+

+use crate::{compositor::Compositor, job, ui};

+

+const ID: &str = "workspace-trust-select";

+

+/// A set of canonicalized workspace paths which have been prompted for trust at runtime.

+static PROMPTED_WORKSPACES: Lazy<Mutex<HashSet<PathBuf>>> =

+ Lazy::new(|| Mutex::new(HashSet::new()));

+

+pub(super) fn register_hooks(_handlers: &Handlers) {

+ register_hook!(move |event: &mut DocumentDidOpen<'_>| {

+ let doc = doc!(event.editor, &event.doc);

+

+ // If there is no servers to be loaded, then the workspace might not be trusted yet

+ if doc.language_servers().next().is_none() {

+ if let TrustUntrustStatus::DenyOnce =

+ quick_query_workspace_with_explicit_untrust(event.editor.config().insecure)

+ {

+ let (workspace, _) = helix_loader::find_workspace();

+ job::dispatch_blocking(|_editor, compositor| prompt(workspace, compositor));

+ }

+ }

+ Ok(())

+ });

+}

+

+pub fn prompt(path: PathBuf, compositor: &mut Compositor) {

+ let mut workspaces = PROMPTED_WORKSPACES.lock();

+ if workspaces.contains(&path) {

+ return;

+ } else {

+ workspaces.insert(path.clone());

+ }

+ let select = select();

+ compositor.replace_or_push(ID, select);

+}

+

+const TRUST_MESSAGE: &str = "Trust this workspace?

+

+Trusted workspaces may load local config files and auto-start language servers. Config and language servers can execute arbitrary code. Only trust workspaces which you know contain harmless config and code.";

+

+fn select() -> ui::Select<TrustUntrustStatus> {

+ ui::Select::new(

+ TRUST_MESSAGE,

+ [

+ TrustUntrustStatus::DenyOnce,

+ TrustUntrustStatus::DenyAlways,

+ TrustUntrustStatus::AllowAlways,

+ ],

+ (),

+ move |editor, option, event| {

+ if event == ui::PromptEvent::Validate {

+ let mut trust = WorkspaceTrust::load(true);

+ match option {

+ TrustUntrustStatus::DenyAlways => {

+ trust.exclude_workspace();

+ }

+ TrustUntrustStatus::DenyOnce => {

+ // Do nothing

+ }

+ TrustUntrustStatus::AllowAlways => {

+ trust.trust_workspace();

+

+ let documents: Vec<DocumentId> = editor.documents.keys().cloned().collect();

+ for document_id in documents.iter() {

+ editor.launch_language_servers(*document_id);

+ }

+

+ let _ = editor

+ .config_events

+ .0

+ .send(helix_view::editor::ConfigEvent::Refresh);

+ }

+ }

+ }

+ },

+ )

+}

+

+impl crate::ui::menu::Item for TrustUntrustStatus {

+ type Data = ();

+

+ fn format(&self, _data: &Self::Data) -> tui::widgets::Row<'_> {

+ match self {

+ TrustUntrustStatus::DenyAlways => "Never",

+ TrustUntrustStatus::DenyOnce => "Not now",

+ TrustUntrustStatus::AllowAlways => "Always",

+ }

+ .into()

+ }

+}

+ let mut syn_loader_conf = match user_lang_config(false) {

+ let syn_loader_conf = match user_lang_config(false) {

+ let lang_loader =

+ helix_core::config::user_lang_loader(config.editor.insecure).unwrap_or_else(|err| {

+ eprintln!("{}", err);

+ eprintln!("Press <ENTER> to continue with default language config");

+ use std::io::Read;

+ // This waits for an enter press.

+ let _ = std::io::stdin().read(&mut []);

+ helix_core::config::default_lang_loader()

+ });

+use helix_loader::workspace_trust::TrustStatus;

+ /// Whether to implicitly trust every workspace or not

+ pub insecure: bool,

+ insecure: false,

+ pub fn launch_language_servers(&mut self, doc_id: DocumentId) {

+ if let TrustStatus::Untrusted =

+ helix_loader::workspace_trust::quick_query_workspace(self.config.load().insecure)

+ {

+ self.set_status(

+ "Current workspace is not trusted. Run `:workspace-trust` to enable all features.",

+ );

+ return;

+ };

+