That said, sounds like it's something they're thinking about:
> It is also hard to break down those permissions, to say “this code can do this, but this other code over here can’t” or when code prompts to escalate privileges where is that code coming from. Hopefully we can figure out an easy to use mechanism coupled with something that would be effective and performant at runtime to try to solve those challenges.
Jokes aside, though, doesn't the MITM only affect users who run the MITM'd script, just like in the browser it only affects users who visit a MITM'd site?
Deno allows you to grant permissions per top-level invocation. So if you have one program that you run by typing `deno run passwordmanager.js` at the console, and another program that you run by typing `deno run downloadfiles.js`, you can give different permissions to each of those "scripts".
But within one program, you can't (easily) give different permissions to different dependencies. If downloadfiles.js imports both http.js and check-if-number-is-even.js, and it wants http.js to be able to access the network, it has to request the access-the-network permission globally. So check-if-number-is-even.js would also be able to access the network. The different "script" files that make up one program all have to have the same permissions.
(Sure, Deno might have other ways to sandbox parts of your program, but so does Node -- Deno's permissions improvements don't really help you in that case.)
You might argue people are wrong to do that, but the fact is it's extremely popular. And if we redesign the security model, we can allow people to do it safely.
Imagine if leftpad.js had no privileges to anything, even if included in an application that has privileges to network, disk, etc.
In almost any other CS field you would be crazy to use non-vetted third-party code and depend on external service providers for your code to simply run.
I can only think of draconian DRM, which puts things in perspective...
That's why a per-library sandbox model seems so beneficial.
It does still seem dramatically different to need to get an escape out of the js sandbox than to just be handed privileges by design.
Particularly if (in some glorious future) the js vm is written in a safe language, not C++.
Some people are realizing it is not a good idea to download random code. So the solution proposed by Deno is to sandbox it and put a capabilities system into it, rather than create a culture of proper dependency management.
At least they are trying...
With node, it is very opaque. With deno, as I see it, http.js can easily check the permissions for number-is-even.js, and you can easily check the permissions of http.js. It’s not perfect, but I think each link in the dependency chain is at least more easily auditable, even if it is not strictly more secure.
For example, if you only whitelisted --allow-net=api.example.com, it would be a lot more annoying for a rogue dependency to exfiltrate data.
this is actually quite a difficult problem to solve. You're balancing the security needs with usability.
Browsers have an advantage on this aspect, because they can make the assumption that the webpage does not require filesystem access.
i think fully sandboxed OS-esque security model is the only way this can work. Like on android, where each app sees only their own filesystem, and app-to-app interaction is done via a permission based system that the user has to approve.
It maybe more isolated if it follows the nix file system model?
const status = await Deno.permissions.revoke({ name: "run" });
assert(status.state !== "granted")
import * from "https://shady-site.com/this-file-cannot-run-processes.ts"
> The Deno CLI works like a browser, but for code. You import a URL in the code and Deno will go and fetch that code and cache it locally, just like a browser. Also, like a browser, your code runs in a sandbox, which has zero trust of the code you are running, irrespective of the source. You, the person invoking the code, get to tell that code what it can and can’t do, externally. Also, like a browser, code can ask you permission to do things, which you can choose to grant or deny.
The big problem with Deno is that permissions, once granted, apply to every imported URL. You cannot ask it to let one script access the file system, another access network and the rest of them run fully sandboxed. This makes it so that you either only import scripts you already fully trust (making the permission system useless) or don't allow any access (making the ecosystem useless).