Files

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}.`);
}