mirror of
https://github.com/bitwarden/clients.git
synced 2026-11-16 07:03:29 +00:00
295 lines
11 KiB
JavaScript
295 lines
11 KiB
JavaScript
/* eslint-disable @typescript-eslint/no-require-imports, no-console */
|
|
require("dotenv").config();
|
|
const child_process = require("child_process");
|
|
const path = require("path");
|
|
|
|
const { flipFuses, FuseVersion, FuseV1Options } = require("@electron/fuses");
|
|
const builder = require("electron-builder");
|
|
const fse = require("fs-extra");
|
|
exports.default = run;
|
|
|
|
const IS_GITHUB_ACTIONS = process.env.GITHUB_ACTIONS == "true";
|
|
|
|
/// The native messaging proxy's entitlements, per app ID. The browser launches the proxy rather
|
|
/// than the app, so it inherits nothing and has to name the App Group itself -- and the group is
|
|
/// named after the app, so each channel needs its own.
|
|
const PROXY_ENTITLEMENTS = {
|
|
"com.bitwarden.desktop": "entitlements.desktop_proxy.plist",
|
|
"com.bitwarden.beta.desktop": "entitlements.desktop_proxy.beta.plist",
|
|
};
|
|
|
|
/**
|
|
*
|
|
* @param {builder.AfterPackContext} context
|
|
*/
|
|
async function run(context) {
|
|
if (IS_GITHUB_ACTIONS) {
|
|
console.log(`::group::After Pack (${builder.Arch[context.arch]})`);
|
|
}
|
|
console.log("## After pack");
|
|
// console.log(context);
|
|
try {
|
|
await doBuild(context);
|
|
} catch (error) {
|
|
console.error("### Error occurred during after-pack phase:", error.stack);
|
|
throw error;
|
|
} finally {
|
|
if (IS_GITHUB_ACTIONS) {
|
|
console.log(`::endgroup::`);
|
|
}
|
|
}
|
|
}
|
|
|
|
async function doBuild(context) {
|
|
const isMacOsBuild = ["darwin", "mas"].includes(context.electronPlatformName);
|
|
|
|
let isTargetArch;
|
|
if (!isMacOsBuild) {
|
|
isTargetArch = true;
|
|
} else {
|
|
// When running a universal macOS build, afterPack is called once per arch:
|
|
// x64, arm64, and then finally for universal. For an explicit single-arch
|
|
// build (--x64 / --arm64) it is called only once, for that arch.
|
|
//
|
|
// To determine whether this is the target arch, we need to compare the
|
|
// packager's configured targets with the current target.
|
|
const requestedArchs = context.packager.info.options.targets?.get(context.packager.platform);
|
|
const isUniversalRequested = requestedArchs?.has(builder.Arch.universal) ?? false;
|
|
isTargetArch = isUniversalRequested ? context.arch === builder.Arch.universal : true;
|
|
}
|
|
|
|
// TODO: Update this to isTargetArch, and remove resetAdHocDarwinSignature parameter below.
|
|
if (context.packager.platform.nodeName !== "darwin" || context.arch === builder.Arch.universal) {
|
|
await addElectronFuses(context);
|
|
}
|
|
|
|
if (context.electronPlatformName === "linux") {
|
|
console.log("Creating memory-protection wrapper script");
|
|
const appOutDir = context.appOutDir;
|
|
const oldBin = path.join(appOutDir, context.packager.executableName);
|
|
const newBin = path.join(appOutDir, "bitwarden-app");
|
|
fse.moveSync(oldBin, newBin);
|
|
console.log("Moved binary to bitwarden-app");
|
|
|
|
const wrapperScript = path.join(__dirname, "../resources/linux-wrapper.sh");
|
|
const wrapperBin = path.join(appOutDir, context.packager.executableName);
|
|
fse.copyFileSync(wrapperScript, wrapperBin);
|
|
fse.chmodSync(wrapperBin, "755");
|
|
console.log("Copied memory-protection wrapper script");
|
|
}
|
|
|
|
if (isMacOsBuild) {
|
|
if (isTargetArch) {
|
|
console.log("[macOS] Copying extensions...");
|
|
copyMacOsAutofillExtension(context);
|
|
copySafariExtension(context);
|
|
}
|
|
const is_mas = context.electronPlatformName === "mas";
|
|
|
|
let id;
|
|
|
|
// Only use the Bitwarden Identities on CI
|
|
if (process.env.GITHUB_ACTIONS === "true") {
|
|
if (is_mas) {
|
|
id = "3rd Party Mac Developer Application: Bitwarden Inc";
|
|
} else {
|
|
id = "Developer ID Application: Bitwarden Inc";
|
|
}
|
|
// Locally, use the first valid code signing identity, unless CSC_NAME is set
|
|
} else if (process.env.CSC_NAME) {
|
|
id = process.env.CSC_NAME;
|
|
} else {
|
|
const identities = getIdentities();
|
|
if (identities.length === 0) {
|
|
throw new Error("No valid identities found");
|
|
}
|
|
id = identities[0].id;
|
|
}
|
|
|
|
console.log(
|
|
`Signing proxy binary before the main bundle, using identity '${id}', for build ${context.electronPlatformName}`,
|
|
);
|
|
|
|
const appName = context.packager.appInfo.productFilename;
|
|
const appPath = `${context.appOutDir}/${appName}.app`;
|
|
const proxyPath = path.join(appPath, "Contents", "MacOS", "desktop_proxy");
|
|
const inheritProxyPath = path.join(appPath, "Contents", "MacOS", "desktop_proxy.inherit");
|
|
|
|
const packageId = context.packager.appInfo.id;
|
|
|
|
// Sandbox the proxy and scope it to the App Group on Developer ID builds as well as App Store
|
|
// ones, so both reach the same shared container the app listens on. Without the group the
|
|
// proxy resolves its socket to its own cache directory, which the app cannot see.
|
|
const entitlementsName = PROXY_ENTITLEMENTS[packageId];
|
|
if (entitlementsName === undefined) {
|
|
throw new Error(`No desktop_proxy entitlements for app ID '${packageId}'`);
|
|
}
|
|
const entitlementsPath = path.join(__dirname, "..", "resources", entitlementsName);
|
|
child_process.execSync(
|
|
`codesign -s '${id}' -i ${packageId} -f --timestamp --options runtime --entitlements "${entitlementsPath}" "${proxyPath}"`,
|
|
);
|
|
|
|
// The App Store build spawns the inherit helper as a child of the sandboxed app, so it takes
|
|
// the app's sandbox -- and its App Group membership -- through the inherit entitlement. For
|
|
// non-Appstore builds, we don't need the inherit binary as they are not sandboxed, but we sign
|
|
// and include it anyway for consistency. It should be removed once DDG supports the proxy
|
|
// directly.
|
|
const inheritEntitlementsName = is_mas
|
|
? "entitlements.desktop_proxy.inherit.plist"
|
|
: "entitlements.mac.inherit.plist";
|
|
const inheritEntitlementsPath = path.join(
|
|
__dirname,
|
|
"..",
|
|
"resources",
|
|
inheritEntitlementsName,
|
|
);
|
|
child_process.execSync(
|
|
`codesign -s '${id}' -i ${packageId} -f --timestamp --options runtime --entitlements "${inheritEntitlementsPath}" "${inheritProxyPath}"`,
|
|
);
|
|
}
|
|
}
|
|
|
|
// Partially based on electron-builder code:
|
|
// https://github.com/electron-userland/electron-builder/blob/master/packages/app-builder-lib/src/macPackager.ts
|
|
// https://github.com/electron-userland/electron-builder/blob/master/packages/app-builder-lib/src/codeSign/macCodeSign.ts
|
|
|
|
const appleCertificatePrefixes = [
|
|
"Developer ID Application:",
|
|
// "Developer ID Installer:",
|
|
// "3rd Party Mac Developer Application:",
|
|
// "3rd Party Mac Developer Installer:",
|
|
"Apple Development:",
|
|
];
|
|
|
|
function getIdentities() {
|
|
const ids = child_process
|
|
.execSync("/usr/bin/security find-identity -v -p codesigning")
|
|
.toString();
|
|
|
|
return ids
|
|
.split("\n")
|
|
.filter((line) => {
|
|
for (const prefix of appleCertificatePrefixes) {
|
|
if (line.includes(prefix)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
})
|
|
.map((line) => {
|
|
const split = line.trim().split(" ");
|
|
const id = split[1];
|
|
const name = split.slice(2).join(" ").replace(/"/g, "");
|
|
return { id, name };
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @param {import("electron-builder").AfterPackContext} context
|
|
*/
|
|
async function addElectronFuses(context) {
|
|
const platform = context.packager.platform.nodeName;
|
|
|
|
const ext = {
|
|
darwin: ".app",
|
|
win32: ".exe",
|
|
linux: "",
|
|
}[platform];
|
|
|
|
const IS_LINUX = platform === "linux";
|
|
const executableName = IS_LINUX
|
|
? context.packager.appInfo.productFilename.toLowerCase().replace("-dev", "").replace(" ", "-")
|
|
: context.packager.appInfo.productFilename; // .toLowerCase() to accommodate Linux file named `name` but productFileName is `Name` -- Replaces '-dev' because on Linux the executable name is `name` even for the DEV builds
|
|
|
|
const electronBinaryPath = path.join(context.appOutDir, `${executableName}${ext}`);
|
|
|
|
console.log("## Adding fuses to the electron binary", electronBinaryPath);
|
|
|
|
await flipFuses(electronBinaryPath, {
|
|
version: FuseVersion.V1,
|
|
strictlyRequireAllFuses: true,
|
|
resetAdHocDarwinSignature: platform === "darwin" && context.arch === builder.Arch.universal,
|
|
|
|
// List of fuses and their default values is available at:
|
|
// https://www.electronjs.org/docs/latest/tutorial/fuses
|
|
|
|
[FuseV1Options.RunAsNode]: false,
|
|
[FuseV1Options.EnableCookieEncryption]: true,
|
|
[FuseV1Options.EnableNodeOptionsEnvironmentVariable]: false,
|
|
[FuseV1Options.EnableNodeCliInspectArguments]: false,
|
|
|
|
// Currently, asar integrity is only implemented for macOS and Windows
|
|
// https://www.electronjs.org/docs/latest/tutorial/asar-integrity
|
|
[FuseV1Options.EnableEmbeddedAsarIntegrityValidation]:
|
|
platform == "darwin" || platform == "win32",
|
|
|
|
[FuseV1Options.OnlyLoadAppFromAsar]: true,
|
|
|
|
// App refuses to open when enabled
|
|
[FuseV1Options.LoadBrowserProcessSpecificV8Snapshot]: false,
|
|
|
|
// To disable this, we should stop using the file:// protocol to load the app bundle
|
|
// This can be done by defining a custom app:// protocol and loading the bundle from there,
|
|
// but then any requests to the server will be blocked by CORS policy
|
|
[FuseV1Options.GrantFileProtocolExtraPrivileges]: true,
|
|
|
|
// Enables V8 signal handlers to trap Out of Bounds memory access from WebAssembly
|
|
[FuseV1Options.WasmTrapHandlers]: true,
|
|
});
|
|
}
|
|
|
|
function copyMacOsAutofillExtension(context) {
|
|
const extensionPath = path.join(__dirname, "../macos/dist/autofill-extension.appex");
|
|
// Every macOS build ships the extension, so a missing one is a broken build rather than a
|
|
// configuration that leaves it out.
|
|
if (!fse.existsSync(extensionPath)) {
|
|
throw new Error(
|
|
`Autofill extension not found at ${extensionPath}; macOS builds must include it. Build it first with one of the "build:macos-extension:*" npm scripts.`,
|
|
);
|
|
}
|
|
copyMacOsPlugin(context, "Autofill extension", extensionPath);
|
|
}
|
|
|
|
function copySafariExtension(context) {
|
|
const plugIn = path.join(__dirname, "../PlugIns", "safari.appex");
|
|
copyMacOsPlugin(context, "Safari Extension", plugIn);
|
|
}
|
|
|
|
function copyMacOsPlugin(context, targetName, extensionPath) {
|
|
// Pre-signed macOS extensions are copied here in after-pack.js, before electron-builder signs the app, so that
|
|
// the app's own signature seals it.
|
|
//
|
|
// Copying it in after signing leaves the outer bundle invalid ("a sealed
|
|
// resource is missing or invalid") and notarization rejects it unless the
|
|
// whole package is signed a second time. electron-builder never signs
|
|
// anything under Contents/PlugIns, so the extension keeps the signature and
|
|
// entitlements XCode gave it.
|
|
//
|
|
// We cannot use extraFiles because it modifies the extension's .plist and makes it invalid. Cf.
|
|
// https://github.com/electron-userland/electron-builder/issues/5552.
|
|
|
|
if (!["darwin", "mas"].includes(context.electronPlatformName)) {
|
|
// not a macOS build, skipping.
|
|
console.log(`### ${targetName}: Not macOS build. Skipping.`);
|
|
return;
|
|
}
|
|
|
|
if (!fse.existsSync(extensionPath)) {
|
|
console.log(`### ${targetName}: ${extensionPath} not found - skipping`);
|
|
return;
|
|
}
|
|
|
|
console.log(`### ${targetName}: Copying plugin...`);
|
|
|
|
// Make PlugIns directory.
|
|
const appName = context.packager.appInfo.productFilename;
|
|
const plugInsPath = path.join(context.appOutDir, `${appName}.app`, "Contents/PlugIns");
|
|
fse.mkdirSync(plugInsPath, { recursive: true });
|
|
|
|
// Copy extension
|
|
const name = path.basename(extensionPath);
|
|
const output = path.join(plugInsPath, name);
|
|
fse.copySync(extensionPath, output);
|
|
console.log(`### ${targetName}: Copied ${extensionPath} to ${output}.`);
|
|
}
|