pjs-rs 0.1.5

A javascript runtime with [pjs](https://github.com/polkadot-js) embebed
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use std::borrow::Cow;
use std::path::{Path, PathBuf};

use deno_core::url::Url;
use deno_fetch::FetchPermissions;
use deno_io::fs::FsError;
use deno_net::NetPermissions;
use deno_permissions::PermissionCheckError;
use deno_web::TimersPermission;
use deno_websocket::WebSocketPermissions;

pub struct ZombiePermissions;

impl TimersPermission for ZombiePermissions {
    fn allow_hrtime(&mut self) -> bool {
        // Disable high-resolution time management.
        //
        // Quoting from https://v8.dev/docs/untrusted-code-mitigations
        // > A high-precision timer makes it easier to observe side channels in the SSCA
        // > vulnerability. If your product offers high-precision timers that can be accessed by
        // > untrusted JavaScript or WebAssembly code, consider making these timers more coarse or
        // > adding jitter to them.
        false
    }
}

impl WebSocketPermissions for ZombiePermissions {
    fn check_net_url(
        &mut self,
        _url: &deno_core::url::Url,
        _api_name: &str,
    ) -> Result<(), PermissionCheckError> {
        Ok(())
    }
}

impl FetchPermissions for ZombiePermissions {
    fn check_net_url(&mut self, _url: &Url, _api_name: &str) -> Result<(), PermissionCheckError> {
        Ok(())
    }

    fn check_read<'a>(
        &mut self,
        _resolved: bool,
        p: &'a Path,
        _api_name: &str,
    ) -> Result<Cow<'a, Path>, FsError> {
        Ok(p.into())
    }
}

impl NetPermissions for ZombiePermissions {
    fn check_net<T: AsRef<str>>(
        &mut self,
        _host: &(T, Option<u16>),
        _api_name: &str,
    ) -> Result<(), PermissionCheckError> {
        Ok(())
    }

    fn check_read(&mut self, p: &str, _api_name: &str) -> Result<PathBuf, PermissionCheckError> {
        Ok(p.into())
    }

    fn check_write(&mut self, p: &str, _api_name: &str) -> Result<PathBuf, PermissionCheckError> {
        Ok(p.into())
    }

    fn check_write_path<'a>(
        &mut self,
        p: &'a Path,
        _api_name: &str,
    ) -> Result<Cow<'a, Path>, PermissionCheckError> {
        Ok(p.into())
    }
}