安全性，原生能力和你的责任

Web开发人员通常享有浏览器强大的网络安全特性，而自己的代码风险相对较小。 我们的网站从沙箱获得有限权限。我们坚信用户可以享受一个大的工程师团队构建的浏览器，因为他们能够快速响应新发现的安全威胁。

当使用 Electron 时，很重要的一点是要理解 Electron 不是一个 Web 浏览器。 它允许您使用熟悉的 Web 技术构建功能丰富的桌面应用程序，但是您的代码具有更强大的功能。 JavaScript 可以访问文件系统，用户 shell 等。 这允许您构建更高质量的本机应用程序，但是内在的安全风险会随着授予您的代码的额外权力而增加。

考虑到这一点，请注意，展示任意来自不受信任源的内容都将会带来严重的安全风险，而这种风险Electron也没打算处理。 事实上，最流行的 Electron 应用程序(Atom，Slack，Visual Studio Code 等) 主要显示本地内容(即使有远程内容也是无 Node 的、受信任的、安全的内容) - 如果您的应用程序要运行在线的源代码，那么您需要确保源代码不是恶意的。

报告安全问题

有关如何正确上报 Electron 漏洞的信息，参阅 SECURITY.md

Chromium 安全问题和升级

尽管 Electron 努力尽快支持新版本的 Chromium，但开发人员应该意识到，升级是一项严肃的工作 - 涉及手动编辑几十个甚至几百个文件。 受限于当前可用的资源与贡献，Electron 通常不能保持使用最新版本的 Chromium，可能落后几周或几个月。

我们认为，我们当前的更新 Chromium 组件的系统在我们可用的资源和构建在框架之上的大多数应用程序的需求之间取得了适当的平衡。 我们绝对有兴趣听听更多关于在 Electron 上构建事物的人的具体用例。 非常欢迎提出请求并且捐助支持我们的努力。

Security Is Everyone's Responsibility

It is important to remember that the security of your Electron application is the result of the overall security of the framework foundation (Chromium, Node.js), Electron itself, all NPM dependencies and your code. As such, it is your responsibility to follow a few important best practices:

  • Keep your application up-to-date with the latest Electron framework release. When releasing your product, you’re also shipping a bundle composed of Electron, Chromium shared library and Node.js. Vulnerabilities affecting these components may impact the security of your application. By updating Electron to the latest version, you ensure that critical vulnerabilities (such as nodeIntegration bypasses) are already patched and cannot be exploited in your application.

  • Evaluate your dependencies. While NPM provides half a million reusable packages, it is your responsibility to choose trusted 3rd-party libraries. If you use outdated libraries affected by known vulnerabilities or rely on poorly maintained code, your application security could be in jeopardy.

  • Adopt secure coding practices. The first line of defense for your application is your own code. Common web vulnerabilities, such as Cross-Site Scripting (XSS), have a higher security impact on Electron applications hence it is highly recommended to adopt secure software development best practices and perform security testing.

Isolation For Untrusted Content

A security issue exists whenever you receive code from an untrusted source (e.g. a remote server) and execute it locally. As an example, consider a remote website being displayed inside a default BrowserWindow. If an attacker somehow manages to change said content (either by attacking the source directly, or by sitting between your app and the actual destination), they will be able to execute native code on the user's machine.

⚠️无论如何，在启用Node.js集成的情况下，你都不该加载并执行远程代码。 相反，只使用本地文件（和您的应用打包在一起）来执行Node.js代码 To display remote content, use the <webview> tag or BrowserView, make sure to disable the nodeIntegration and enable contextIsolation.

Electron 安全警告

从Electron 2.0版本开始，开发者将会在开发者控制台看到打印的警告和建议。 这些警告仅在可执行文件名为 Electron 时才会为开发者显示。

你可以通过在process.env 或 window对象上配置ELECTRON_ENABLE_SECURITY_WARNINGS 或ELECTRON_DISABLE_SECURITY_WARNINGS来强制开启或关闭这些警告。

清单：安全建议

You should at least follow these steps to improve the security of your application:

1) 仅加载安全内容

任何不属于你的应用的资源都应该使用像HTTPS这样的安全协议来加载。 换言之， 不要使用不安全的协议 （如 HTTP）。 同理，我们建议使用WSS，避免使用WS，建议使用FTPS ，避免使用FTP，等等诸如此类的协议。

为什么？

HTTPS 有三个主要好处：

1) 它对远程服务器进行身份验证, 确保您的应用程序连接到正确的主机而不是模仿器。 2) 确保数据完整性, 断言数据在应用程序和主机之间传输时未被修改。 3) 它对用户和目标主机之间的通信进行加密, 从而更难窃听应用程序和主机之间发送的信息。

怎么做？

  1. // 不推荐
  2. browserWindow.loadURL ('http://example.com')
  3. // 推荐 
  4. browserWindow.loadURL ('https://example.com')
  1. <!-- 不推荐 -->
  2. <script crossorigin src="http://example.com/react.js"></script>
  3. <link rel="stylesheet" href="http://example.com/style.css">
  5. <!-- 推荐 -->
  6. <script crossorigin src="https://example.com/react.js"></script>
  7. <link rel="stylesheet" href="https://example.com/style.css">

2) 禁止Node.js集成远程内容

加载远程内容时，不论是使用BrowserWindow，BrowserView 还是 <webview>，首要任务都是禁用 Node.js 集成。 其目的是限制您授予远程内容的权限, 从而使攻击者在您的网站上执行 JavaScript 时更难伤害您的用户。

在此之后，你可以为指定的主机授予附加权限。 举例来说，如果你正在打开一个指向 "https://example.com/" 的 BrowserWindow，你可以给它正好所需的权限，无需再多。

为什么？

如果攻击者跳过渲染进程并在用户电脑上执行恶意代码，那么这种跨站脚本(XSS) 攻击的危害是非常大的。 跨站脚本攻击很常见，通常情况下，威力仅限于执行代码的网站。 禁用Node.js集成有助于防止XSS攻击升级为“远程代码执行” (RCE) 攻击。

怎么做？

  1. // 不推荐
  2. const mainWindow = new BrowserWindow()
  3. mainWindow.loadURL('https://example.com')
  1. // Good
  2. const mainWindow = new BrowserWindow({
  3.   webPreferences: {
  4.     nodeIntegration: false,
  5.     nodeIntegrationInWorker: false,
  6.     preload: './preload.js'
  7.   }
  8. })
  10. mainWindow.loadURL('https://example.com')
  1. <!-- 不推荐 -->
  2. <webview nodeIntegration src="page.html"></webview>
  4. <!-- 推荐 -->
  5. <webview src="page.html"></webview>

当禁用Node.js集成时，你依然可以暴露API给你的站点以使用Node.js的模块功能或特性。 预加载脚本依然可以使用require等Node.js特性， 以使开发者可以暴露自定义API给远程加载内容。

在下面的预加载脚本例子中，后加载的网站内容可以使用window.readConfig()方法，但不能使用Node.js特性。

  1. const { readFileSync } = require('fs')
  3. window.readConfig = function () {
  4.   const data = readFileSync('./config.json')
  5.   return data
  6. }

3) 为远程内容开启上下文隔离

上下文隔离是Electron的一个特性，它允许开发者在预加载脚本里运行代码，里面包含Electron API和专用的JavaScript上下文。 实际上，这意味全局对象如 Array.prototype.push 或 JSON.parse等无法被渲染进程里的运行脚本修改。

Electron使用了和Chromium相同的Content Scripts技术来开启这个行为。

Even when you use nodeIntegration: false to enforce strong isolation and prevent the use of Node primitives, contextIsolation must also be used.

为什么？

上下文隔离使得每个运行在渲染器上的脚本无需担心改变JavaScript环境变量而与ElectronAPI或预加载脚本发生冲突。

While still an experimental Electron feature, context isolation adds an additional layer of security. It creates a new JavaScript world for Electron APIs and preload scripts, which mitigates so-called "Prototype Pollution" attacks.

同时，预加载脚本依然能访问document和window对象。换个角度，就像你以很小的投入却得到双倍回报一样。

怎么做？

  1. // 主进程
  2. const mainWindow = new BrowserWindow({
  3.   webPreferences: {
  4.     contextIsolation: true,
  5.     preload: 'preload.js'
  6.   }
  7. })
  1. // 预加载脚本
  3. // 在页面加载前设置变量
  4. webFrame.executeJavaScript('window.foo = "foo";')
  6. // 这个变量仅限于当前上下文，被加载的页面将无权访问
  7. window.bar = 'bar'
  9. document.addEventListener('DOMContentLoaded', () => {
  10.   // 结果为 'undefined'，因为 window.foo 仅在主上下文中可用
  11.   console.log(window.foo)
  13.   // 结果为 'bar'，因为 window.bar 定义在本上下文中
  14.   console.log(window.bar)
  15. })

4) 处理来自远程内容的会话许可请求

当你使用Chromes时，也许见过这种许可请求：每当网站尝试使用某个特性时，就会弹出让用户手动确认(如网站通知)

此API基于Chromium permissions API，并已实现对应的许可类型。

为什么？

默认情况下，Electron将自动批准所有的许可请求，除非开发者手动配置一个自定义处理函数。 尽管默认如此，有安全意识的开发者可能希望默认反着来。

怎么做？

  1. const { session } = require('electron')
  3. session
  4.   .fromPartition('some-partition')
  5.   .setPermissionRequestHandler((webContents, permission, callback) => {
  6.     const url = webContents.getURL()
  8.     if (permission === 'notifications') {
  9.       // Approves the permissions request
  10.       callback(true)
  11.     }
  13.     // Verify URL
  14.     if (!url.startsWith('https://example.com/')) {
  15.       // Denies the permissions request
  16.       return callback(false)
  17.     }
  18.   })

5) 不要禁用WebSecurity

Electron的默认值即是建议值。

在渲染进程（BrowserWindow、BrowserView 和 <webview>）中禁用 webSecurity 将导致至关重要的安全性功能被关闭。

不要在生产环境中禁用webSecurity。

为什么？

禁用 webSecurity 将会禁止同源策略并且将 allowRunningInsecureContent 属性置 true。 换句话说，这将使得来自其他站点的非安全代码被执行。

怎么做？

  1. // 不推荐
  2. const mainWindow = new BrowserWindow({
  3.   webPreferences: {
  4.     webSecurity: false
  5.   }
  6. })
  1. // 推荐
  2. const mainWindow = new BrowserWindow()
  1. <!-- 不推荐 -->
  2. <webview disablewebsecurity src="page.html"></webview>
  4. <!-- 推荐 -->
  5. <webview src="page.html"></webview>

6) 定义一个内容安全策略

内容安全策略(CSP) 是应对跨站脚本攻击和数据注入攻击的又一层保护措施。 我们建议任何载入到Electron的站点都要开启。

为什么？

CSP允许Electron通过服务端内容对指定页面的资源加载进行约束与控制。 如果你定义https://example.com这个源，所属这个源的脚本都允许被加载，反之https://evil.attacker.com不会被允许加载运行。 对于提升你的应用安全性，设置CSP是个很方便的办法。

下面的CSP设置使得Electron只能执行自身站点和来自apis.example.com的脚本。

  1. // 不推荐
  2. Content-Security-Policy: '*'
  4. // 推荐
  5. Content-Security-Policy: script-src 'self' https://apis.example.com

CSP HTTP头

Electron 会处理 Content-Security-Policy HTTP 标头，它可以在 webRequest.onHeadersReceived 中进行设置：

  1. const { session } = require('electron')
  3. session.defaultSession.webRequest.onHeadersReceived((details, callback) => {
  4.   callback({
  5.     responseHeaders: {
  6.       ...details.responseHeaders,
  7.       'Content-Security-Policy': ['default-src \'none\'']
  8.     }
  9.   })
  10. })

CSP元标签

CSP的首选传递机制是HTTP报头，但是在使用file://协议加载资源时，不可能使用此方法。 It can be useful in some cases, such as using the file:// protocol, to set a policy on a page directly in the markup using a <meta> tag:

  1. <meta http-equiv="Content-Security-Policy" content="default-src 'none'">

webRequest.onHeadersReceived([filter, ]listener)

7) 不要设置allowRunningInsecureContent为true

Electron的默认值即是建议值。

默认情况下，Electron不允许网站在HTTPS中加载或执行非安全源(HTTP) 中的脚本代码、CSS或插件。 将allowRunningInsecureContent属性设为true将禁用这种保护。

当网站的初始内容通过HTTPS加载并尝试在子请求中加载HTTP的资源时，这被称为"混合内容"。

为什么？

通过HTTPS加载会将该资源进行加密传输，以保证其真实性和完整性。 参看只显示安全内容这节以获得更多信息。

怎么做？

  1. // 不推荐
  2. const mainWindow = new BrowserWindow({
  3.   webPreferences: {
  4.     allowRunningInsecureContent: true
  5.   }
  6. })
  1. // 推荐
  2. const mainWindow = new BrowserWindow({})

8) 不要开启实验室特性

Electron的默认值即是建议值。

Electron 的熟练用户可以通过 experimentalFeatures 属性来启用 Chromium 实验性功能。

为什么？

实验室特性，恰如其名，是实验性质且不对所有Chromium用户开启。更进一步说，这些特性对Electron的整体影响可能没有测试。

尽管存在合理的使用场景，但是除非你知道你自己在干什么，否则你不应该开启这个属性。

怎么做？

  1. // 不推荐
  2. const mainWindow = new BrowserWindow({
  3.   webPreferences: {
  4.     experimentalFeatures: true
  5.   }
  6. })
  1. // 推荐
  2. const mainWindow = new BrowserWindow({})

9) 不要使用enableBlinkFeatures

Electron的默认值即是建议值。

Blink是Chromium里的渲染引擎名称。 就像experimentalFeatures一样，enableBlinkFeatures属性将使开发者启用被默认禁用的特性。

为什么？

通常来说，某个特性默认不被开启肯定有其合理的原因。 针对特定特性的合理使用场景是存在的。 作为开发者，你应该非常明白你为何要开启它，有什么后果，以及对你应用安全性的影响。 在任何情况下都不应该推测性的开启特性。

怎么做？

  1. // 不推荐
  2. const mainWindow = new BrowserWindow({
  3.   webPreferences: {
  4.     enableBlinkFeatures: ['ExecCommandInJavaScript']
  5.   }
  6. })
  1. // 推荐
  2. const mainWindow = new BrowserWindow()

10) 不要使用allowpopups

Electron的默认值即是建议值。

如果您正在使用 <webview> ，您可能需要页面和脚本加载进您的 <webview> 标签以打开新窗口。 开启allowpopups属性将使得BrowserWindows可以通过window.open()方法创建。 否则， <webview> 标签内不允许创建新窗口。

为什么？

如果你不需要弹窗，最好使用默认值以关闭新BrowserWindows的创建。 以下是最低的权限要求原则：若非必要，不要再网站中创建新窗口。

怎么做？

  1. <!-- 不推荐 -->
  2. <webview allowpopups src="page.html"></webview>
  4. <!-- 推荐 -->
  5. <webview src="page.html"></webview>

11) 创建WebView前确认其选项

通过渲染进程创建的WebView是不开启Node.js集成的，且也不能由自身开启。 但是，WebView可以通过其webPreferences属性创建一个独立的渲染进程。

It is a good idea to control the creation of new <webview> tags from the main process and to verify that their webPreferences do not disable security features.

为什么？

Since <webview> live in the DOM, they can be created by a script running on your website even if Node.js integration is otherwise disabled.

Electron 可以让开发者关闭各种控制渲染进程的安全特性。 In most cases, developers do not need to disable any of those features - and you should therefore not allow different configurations for newly created <webview> tags.

怎么做？

Before a <webview> tag is attached, Electron will fire the will-attach-webview event on the hosting webContents. 利用这个事件来阻止可能含有不安全选项的 webViews 创建。

  1. app.on('web-contents-created', (event, contents) => {
  2.   contents.on('will-attach-webview', (event, webPreferences, params) => {
  3.     // Strip away preload scripts if unused or verify their location is legitimate
  4.     delete webPreferences.preload
  5.     delete webPreferences.preloadURL
  7.     // Disable Node.js integration
  8.     webPreferences.nodeIntegration = false
  10.     // Verify URL being loaded
  11.     if (!params.src.startsWith('https://example.com/')) {
  12.       event.preventDefault()
  13.     }
  14.   })
  15. })

强调一下，这份列表只是将风险降到最低，并不会完全屏蔽风险。 如果您的目的是展示一个网站，浏览器将是一个更安全的选择。

12) Disable or limit navigation

If your app has no need to navigate or only needs to navigate to known pages, it is a good idea to limit navigation outright to that known scope, disallowing any other kinds of navigation.

为什么？

Navigation is a common attack vector. If an attacker can convince your app to navigate away from its current page, they can possibly force your app to open web sites on the Internet. Even if your webContents are configured to be more secure (like having nodeIntegration disabled or contextIsolation enabled), getting your app to open a random web site will make the work of exploiting your app a lot easier.

A common attack pattern is that the attacker convinces your app's users to interact with the app in such a way that it navigates to one of the attacker's pages. This is usually done via links, plugins, or other user-generated content.

怎么做？

If your app has no need for navigation, you can call event.preventDefault() in a will-navigate handler. If you know which pages your app might navigate to, check the URL in the event handler and only let navigation occur if it matches the URLs you're expecting.

We recommend that you use Node's parser for URLs. Simple string comparisons can sometimes be fooled - a startsWith('https://example.com&#39;) test would let https://example.com.attacker.com through.

  1. const URL = require('url').URL
  3. app.on('web-contents-created', (event, contents) => {
  4.   contents.on('will-navigate', (event, navigationUrl) => {
  5.     const parsedUrl = new URL(navigationUrl)
  7.     if (parsedUrl.origin !== 'https://example.com') {
  8.       event.preventDefault()
  9.     }
  10.   })
  11. })

13) 禁用或限制新窗口的创建

If you have a known set of windows, it's a good idea to limit the creation of additional windows in your app.

为什么？

Much like navigation, the creation of new webContents is a common attack vector. Attackers attempt to convince your app to create new windows, frames, or other renderer processes with more privileges than they had before; or with pages opened that they couldn't open before.

If you have no need to create windows in addition to the ones you know you'll need to create, disabling the creation buys you a little bit of extra security at no cost. This is commonly the case for apps that open one BrowserWindow and do not need to open an arbitrary number of additional windows at runtime.

怎么做？

webContents will emit the new-window event before creating new windows. That event will be passed, amongst other parameters, the url the window was requested to open and the options used to create it. We recommend that you use the event to scrutinize the creation of windows, limiting it to only what you need.

  1. const { shell } = require('electron')
  3. app.on('web-contents-created', (event, contents) => {
  4.   contents.on('new-window', (event, navigationUrl) => {
  5.     // In this example, we'll ask the operating system
  6.     // to open this event's url in the default browser.
  7.     event.preventDefault()
  9.     shell.openExternalSync(navigationUrl)
  10.   })
  11. })

14) Do not use openExternal with untrusted content

Shell's openExternal allows opening a given protocol URI with the desktop's native utilities. On macOS, for instance, this function is similar to the open terminal command utility and will open the specific application based on the URI and filetype association.

为什么？

Improper use of openExternal can be leveraged to compromise the user's host. When openExternal is used with untrusted content, it can be leveraged to execute arbitrary commands.

怎么做？

  1. //  Bad
  2. const { shell } = require('electron')
  3. shell.openExternal(USER_CONTROLLED_DATA_HERE)
  1. //  Good
  2. const { shell } = require('electron')
  3. shell.openExternal('https://example.com/index.html')