sliftutils 1.7.126 → 1.7.127

package/security/authorizedKeys/daemon/rootKeys.ts

@@ -1,8 +1,10 @@
 import fs from "fs/promises";
 import path from "path";
-import { keyFingerprint, keyRestriction, summarizeKey } from "../authorizedKeys";
+import { keyFingerprint, keyRestriction, keyRestrictionList, NO_RESTRICTION, summarizeKey } from "../authorizedKeys";
 import { KEYS_HISTORY_PATH, ROOT_AUTHORIZED_KEYS } from "./paths";
 import { notify } from "./notify";
+import { getState, saveState } from "./state";
+import { takeChangeReasons } from "./changes";
 
 const KEY_FILE_HEADER = "# Managed by portsecure. Manual changes are reverted and reported.";
 
@@ -22,6 +24,35 @@ function keyIdentity(keyLine: string) {
     return keyFingerprint(keyLine) || keyLine;
 }
 
+/** Which addresses a key gained or lost, rather than two long lists to compare by eye. Returns ""
+    when the addresses did not change at all. Losing the from= altogether is the loudest case there
+    is, so it is spelled out rather than shown as a list of removals. */
+function describeAddressChange(config: { previousLine: string; currentLine: string }) {
+    let { previousLine, currentLine } = config;
+    let previous = keyRestrictionList(previousLine);
+    let current = keyRestrictionList(currentLine);
+    if (!previous && !current) {
+        return "";
+    }
+    if (previous && !current) {
+        return `          was ${previous.join(",")}\n          now ${NO_RESTRICTION}`;
+    }
+    if (!previous && current) {
+        return `          was ${NO_RESTRICTION}\n          now restricted to ${current.join(",")}`;
+    }
+    let removed = (previous || []).filter(address => !(current || []).includes(address));
+    let added = (current || []).filter(address => !(previous || []).includes(address));
+    if (!removed.length && !added.length) {
+        return "";
+    }
+    let lines = [
+        ...removed.map(address => `          no longer allowed from ${address}`),
+        ...added.map(address => `          now also allowed from ${address}`),
+    ];
+    lines.push(`          still allowed from ${(current || []).filter(address => !added.includes(address)).join(",") || "nothing"}`);
+    return lines.join("\n");
+}
+
 export function describeKeyDifference(config: { before: string[]; after: string[] }) {
     let { before, after } = config;
     let beforeByKey = new Map(before.map(key => [keyIdentity(key), key]));
@@ -43,17 +74,13 @@ export function describeKeyDifference(config: { before: string[]; after: string[
         if (!currentLine || currentLine === previousLine) {
             continue;
         }
-        let previousFrom = keyRestriction(previousLine);
-        let currentFrom = keyRestriction(currentLine);
-        if (previousFrom !== currentFrom) {
-            lines.push(
-                `~ changed ${summarizeKey(currentLine)}\n          from ${previousFrom}\n`
-                + `            to ${currentFrom}`
-            );
+        let addressChange = describeAddressChange({ previousLine, currentLine });
+        if (addressChange) {
+            lines.push(`~ changed ${summarizeKey(currentLine)}\n${addressChange}`);
             continue;
         }
         lines.push(
-            `~ changed ${summarizeKey(currentLine)}\n          from ${currentFrom}\n`
+            `~ changed ${summarizeKey(currentLine)}\n          from ${keyRestriction(currentLine)}\n`
             + `          its options or comment changed`
         );
     }
@@ -106,30 +133,66 @@ export async function archiveAuthorizedKeys(config: { filePath: string; reason:
     return archivePath;
 }
 
-/** Puts the allowed keys back in place if anything else changed them. */
-export async function enforceRootKeys(config: { keys: string[]; reason: string }) {
-    let { keys, reason } = config;
+function sameKeys(one: string[], two: string[]) {
+    return one.length === two.length && one.every((key, index) => key === two[index]);
+}
+
+/** Puts the allowed keys in place, and says which of the two things happened.
+
+    Whether this was our own doing is decided by comparing what we want against what we last wrote,
+    not by guessing from whether a repo happened to change. A revocation changes what we want
+    without any repo changing, and reading that as somebody having edited the file was both wrong
+    and alarming. */
+export async function enforceRootKeys(keys: string[]) {
+    // An empty set is written out like any other. If every key is revoked then nobody should be
+    // getting in, and the way back is to put a key in the repo, which is already being watched.
     if (!keys.length) {
-        // No sources, or none of them readable. Writing an empty file would lock everyone out, so
-        // whatever access is already in place stays exactly as it is.
-        console.log(`No keys came from any source, leaving ${ROOT_AUTHORIZED_KEYS} as it is`);
-        return;
+        console.log(`No keys are allowed, so ${ROOT_AUTHORIZED_KEYS} is being emptied`);
     }
+    let state = getState();
     let currentKeys = await readAuthorizedKeysFile(ROOT_AUTHORIZED_KEYS);
-    let matches = currentKeys.length === keys.length && currentKeys.every((key, index) => key === keys[index]);
-    if (matches) {
+    if (!state.appliedKeys.length) {
+        // Nothing recorded yet, on a first start or an upgrade. Whatever is in the file is taken as
+        // ours, so the first check reports what actually changes rather than reintroducing every
+        // key that was already there.
+        state.appliedKeys = currentKeys;
+        await saveState();
+    }
+
+    if (sameKeys(currentKeys, keys)) {
+        // Nothing came of whatever was decided this pass, so none of it is reported.
+        takeChangeReasons();
+        if (!sameKeys(state.appliedKeys, keys)) {
+            state.appliedKeys = keys;
+            await saveState();
+        }
         return;
     }
-    let archivePath = await archiveAuthorizedKeys({ filePath: ROOT_AUTHORIZED_KEYS, reason });
+
+    let weChangedIt = !sameKeys(state.appliedKeys, keys);
+    let previouslyApplied = state.appliedKeys;
+    // Still archived, it is just not worth a line in the message. Whoever needs the old file knows
+    // where the history is.
+    await archiveAuthorizedKeys({
+        filePath: ROOT_AUTHORIZED_KEYS,
+        reason: weChangedIt && "update" || "reverted",
+    });
     await writeAuthorizedKeysFile({ filePath: ROOT_AUTHORIZED_KEYS, keys });
-    let difference = describeKeyDifference({ before: currentKeys, after: keys });
-    let archiveNote = archivePath && `\nThe previous file is kept at \`${archivePath}\`.` || "";
-    if (reason === "repo") {
-        await notify(`root's authorized_keys was updated from the keys repo.\n\`\`\`\n${difference}\n\`\`\`${archiveNote}`);
+    state.appliedKeys = keys;
+    await saveState();
+
+    let reasons = takeChangeReasons();
+    let why = reasons.length && `\n\n${reasons.join("\n\n")}` || "";
+    if (weChangedIt) {
+        await notify(
+            `applied authorized key changes:`
+            + `\n\`\`\`\n${describeKeyDifference({ before: previouslyApplied, after: keys })}\n\`\`\`${why}`
+        );
         return;
     }
     await notify(
-        `root's authorized_keys was changed outside portsecure and has been reverted to the keys repo.`
-        + `\n\`\`\`\n${difference}\n\`\`\`${archiveNote}`
+        `root's authorized_keys was edited by something other than portsecure. The edit below has`
+        + ` been undone, and the keys from the repos are back in place.`
+        + `\n\`\`\`\n${describeKeyDifference({ before: keys, after: currentKeys })}\n\`\`\`${why}`
     );
 }

package/security/authorizedKeys/daemon/sessions.ts

@@ -0,0 +1,139 @@
+import fs from "fs/promises";
+import { spawnPromise } from "../../helpers/spawn";
+import { AUTH_LOG_PATH } from "./paths";
+
+// Taking a key out of authorized_keys only stops the next login. Whoever is already connected with
+// it stays connected for as long as they like, which would make revoking a key that is being
+// actively misused close to pointless.
+//
+// sshd names the key it accepted and the process handling that connection on the same line, so the
+// sessions belonging to one key can be ended without touching anyone else's.
+const ACCEPTED = /(?:sshd|sshd-session)\[(\d+)\]:\s+Accepted publickey for (\S+) from (\S+) port (\d+) ssh2: \S+ (SHA256:[A-Za-z0-9+/=]+)/;
+
+export type KeySession = { processId: number; user: string; ip: string; port: string };
+
+export function parseAcceptedSessions(contents: string, fingerprint: string) {
+    let sessions: KeySession[] = [];
+    for (let line of contents.split("\n")) {
+        let match = line.match(ACCEPTED);
+        if (!match || match[5] !== fingerprint) {
+            continue;
+        }
+        sessions.push({ processId: Number(match[1]), user: match[2], ip: match[3], port: match[4] });
+    }
+    return sessions;
+}
+
+/** Process ids are reused, so one is only killed when it is still an ssh session. Killing whatever
+    happens to hold that number now would be far worse than missing a session. */
+async function isSSHSession(processId: number) {
+    try {
+        let name = await fs.readFile(`/proc/${processId}/comm`, "utf8");
+        return name.trim().startsWith("sshd");
+    } catch (e) {
+        return false;
+    }
+}
+
+/** The whole log, not only what is new, because the session being ended may have been established
+    long before the key was misused. */
+async function readWholeAuthLog() {
+    try {
+        return await fs.readFile(AUTH_LOG_PATH, "utf8");
+    } catch (e) {
+        let result = await spawnPromise({
+            command: "journalctl",
+            args: ["-u", "ssh", "-u", "sshd", "--no-pager", "--since", "-30days"],
+        });
+        return result.status === 0 && result.stdout || "";
+    }
+}
+
+/** Ends every live session that authenticated with this key. Returns what was ended, so the
+    revocation can say so rather than leaving it to be discovered. */
+export async function endSessionsUsingKey(fingerprint: string) {
+    let ended: KeySession[] = [];
+    for (let session of parseAcceptedSessions(await readWholeAuthLog(), fingerprint)) {
+        if (session.processId <= 1 || session.processId === process.pid) {
+            continue;
+        }
+        if (!await isSSHSession(session.processId)) {
+            continue;
+        }
+        try {
+            process.kill(session.processId, "SIGKILL");
+            ended.push(session);
+            console.log(`Ended ssh session ${session.processId} (${session.user} from ${session.ip}), it used ${fingerprint}`);
+        } catch (e) {
+            // Gone between looking and killing, which is the outcome we wanted anyway.
+        }
+    }
+    return ended;
+}
+
+/** Whether this process is one connection. The listener is not a connection - it is the process
+    that accepts them - so it is not a candidate here at all.
+
+    Every openssh since 9.8 runs each connection as its own sshd-session. On older ones connections
+    are named sshd too, and the listener is the one systemd started directly with -D. */
+async function isConnectionProcess(processId: number) {
+    let name: string;
+    try {
+        name = (await fs.readFile(`/proc/${processId}/comm`, "utf8")).trim();
+    } catch (e) {
+        return false;
+    }
+    if (name === "sshd-session") {
+        return true;
+    }
+    if (name !== "sshd") {
+        return false;
+    }
+    let commandLine = await fs.readFile(`/proc/${processId}/cmdline`, "utf8").catch(() => "");
+    let parentId = Number((await fs.readFile(`/proc/${processId}/stat`, "utf8").catch(() => "")).split(") ")[1]?.split(" ")[1] || 0);
+    return !commandLine.includes("-D") && parentId !== 1;
+}
+
+/** Disconnects every ssh session on the machine.
+
+    Not only the ones using the key that was just taken away: a session that predates the key being
+    removed is exactly as dangerous, and working out which sessions are still entitled to be here
+    is guesswork. Anyone who still has access can reconnect in a second, and anyone who does not
+    should not be here. */
+export async function endAllSSHSessions() {
+    let ended: number[] = [];
+    for (let entry of await fs.readdir("/proc")) {
+        let processId = Number(entry);
+        if (!processId || processId <= 1 || processId === process.pid) {
+            continue;
+        }
+        if (!await isConnectionProcess(processId)) {
+            continue;
+        }
+        try {
+            process.kill(processId, "SIGKILL");
+            ended.push(processId);
+        } catch (e) {
+            // Gone between looking and killing, which is the outcome we wanted anyway.
+        }
+    }
+    if (ended.length) {
+        console.log(`Disconnected ${ended.length} ssh session(s): ${ended.join(", ")}`);
+    }
+    return ended;
+}
+
+export function describeAllEnded(ended: number[]) {
+    if (!ended.length) {
+        return " Nothing was connected.";
+    }
+    return ` Every ssh session on this machine was disconnected, ${ended.length} of them.`;
+}
+
+export function describeEndedSessions(ended: KeySession[]) {
+    if (!ended.length) {
+        return " Nothing was connected with it.";
+    }
+    return ` ${ended.length} live session(s) using it were killed: `
+        + ended.map(session => `${session.user}@${session.ip}:${session.port}`).join(", ") + ".";
+}

package/security/authorizedKeys/daemon/state.ts

@@ -45,8 +45,16 @@ export type PendingRevocation = {
 export type DaemonState = {
     sources: { [repoURL: string]: SourceState };
     userKeyHashes: { [userName: string]: string };
+    // Held in memory only, never written to disk. Deleting a revocation from the revoke repo does
+    // not bring a key back, because this machine still remembers it - the key that writes
+    // revocations is on every server, so whoever stole one could otherwise erase the record that
+    // shut them out. Restarting the daemon does clear it, which is the way back from a revocation
+    // that should not have happened.
     revocations: { [fingerprint: string]: RevocationState };
     pendingRevocations: PendingRevocation[];
+    // The keys we last wrote out. What tells a change we made apart from one somebody else made:
+    // if this still matches what we want, and the file does not, the file was edited behind us.
+    appliedKeys: string[];
     // Where we had read up to in the auth log, so a restart does not re-report old attempts.
     authLogOffset: number;
     authLogSignature: string;
@@ -57,6 +65,7 @@ let state: DaemonState = {
     userKeyHashes: {},
     revocations: {},
     pendingRevocations: [],
+    appliedKeys: [],
     authLogOffset: 0,
     authLogSignature: "",
 };
@@ -95,7 +104,11 @@ export async function loadState() {
         return;
     }
     try {
-        state = Object.assign(state, JSON.parse(contents));
+        let loaded = JSON.parse(contents);
+        // Revocations are held in memory only, so whatever an older version left on disk is not
+        // read back in. Starting the daemon is what forgets them.
+        delete loaded.revocations;
+        state = Object.assign(state, loaded);
     } catch (e) {
         // Corrupt state only costs us one duplicate notification, so it is not worth failing over.
         console.log(`Ignoring unreadable state file ${STATE_PATH}. ${e}`);
@@ -103,6 +116,7 @@ export async function loadState() {
 }
 
 export async function saveState() {
+    let { revocations, ...persisted } = state;
     await fs.mkdir(path.dirname(STATE_PATH), { recursive: true });
-    await fs.writeFile(STATE_PATH, JSON.stringify(state, undefined, 4), { mode: 0o600 });
+    await fs.writeFile(STATE_PATH, JSON.stringify(persisted, undefined, 4), { mode: 0o600 });
 }

package/security/authorizedKeys/dist/authorizedKeys.ts.cache

@@ -3,14 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
-//exports.readRepoKeys = exports.summarizeKey = exports.keyRestriction = exports.keyFingerprint = exports.normalizeKeys = void 0;
+//exports.readRepoKeys = exports.findKeyProblems = exports.summarizeKey = exports.keyRestriction = exports.keyRestrictionList = exports.NO_RESTRICTION = exports.keyFingerprint = exports.normalizeKeys = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
-// PORTED CODE: security/authorizedKeys/daemon/portsecureDaemon.js contains a plain JS port of normalizeKeys,
-// summarizeKey and readRepoKeys, so it can resolve the same keys with no dependencies. The two
-// must agree on which keys a repo produces - if you change one, make the matching change in the
-// other.
 function normalizeKeys(contents) {
     return contents.split("\n").map(line => line.trim()).filter(line => line && !line.startsWith("#"));
 }
@@ -27,14 +23,25 @@ function keyFingerprint(keyLine) {
     return "SHA256:" + crypto_1.default.createHash("sha256").update(Buffer.from(blob, "base64")).digest("base64").replace(/=+$/, "");
 }
 exports.keyFingerprint = keyFingerprint;
+exports.NO_RESTRICTION = "ANY ADDRESS (no from= restriction)";
+/** The addresses a key may be used from, one by one, or undefined when the key carries no from=
+    at all. Undefined and an empty list are very different things, so they stay distinguishable. */
+function keyRestrictionList(keyLine) {
+    let match = keyLine.match(/from="([^"]*)"/);
+    if (!match) {
+        return undefined;
+    }
+    return match[1].split(",").map(entry => entry.trim()).filter(entry => entry);
+}
+exports.keyRestrictionList = keyRestrictionList;
 /** The addresses a key may be used from, which is the part of an authorized_keys line that
     decides how much a stolen key is worth. A key with no restriction says so loudly. */
 function keyRestriction(keyLine) {
-    let match = keyLine.match(/from="([^"]*)"/);
-    if (!match) {
-        return "ANY ADDRESS (no from= restriction)";
+    let list = keyRestrictionList(keyLine);
+    if (!list) {
+        return exports.NO_RESTRICTION;
     }
-    return match[1];
+    return list.join(",");
 }
 exports.keyRestriction = keyRestriction;
 /** Enough to recognise whose key this is without printing the whole blob. */
@@ -50,6 +57,37 @@ function summarizeKey(keyLine) {
     return `${type} ...${blob.slice(-12)}${comment && ` ${comment}` || ""}`;
 }
 exports.summarizeKey = summarizeKey;
+/** What a set of keys has to satisfy before it is worth signing, as a list of complaints.
+
+    Every key needs a from=, because an unrestricted key can never be caught being used from the
+    wrong place, and being caught is the only thing that triggers a revocation.
+
+    No two keys may allow the same addresses, because that is one person holding two keys: revoking
+    one of them leaves the other working, so the revocation achieves nothing. */
+function findKeyProblems(keys) {
+    let problems = [];
+    let byRestriction = new Map();
+    for (let key of keys) {
+        let restriction = keyRestrictionList(key);
+        if (!restriction) {
+            problems.push(`no from= restriction, so it can be used from anywhere:\n      ${summarizeKey(key)}`);
+            continue;
+        }
+        // Sorted, so the same addresses written in a different order still count as the same.
+        let identity = [...restriction].sort().join(",");
+        byRestriction.set(identity, [...(byRestriction.get(identity) || []), key]);
+    }
+    for (let [restriction, sharing] of byRestriction) {
+        if (sharing.length < 2) {
+            continue;
+        }
+        problems.push(`${sharing.length} keys allow exactly the same addresses (${restriction}), which is one`
+            + ` person holding more than one key:\n`
+            + sharing.map(key => `      ${summarizeKey(key)}`).join("\n"));
+    }
+    return problems;
+}
+exports.findKeyProblems = findKeyProblems;
 /** Reads the authorized keys a repo checkout wants applied. Prefers a top level authorized_keys
     file and otherwise concatenates every .pub at the top level. */
 async function readRepoKeys(repoPath) {
@@ -69,5 +107,5 @@ async function readRepoKeys(repoPath) {
     return keys;
 }
 exports.readRepoKeys = readRepoKeys;
-//# sourceMappingURL=data:application/json;base64,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
- /* _JS_SOURCE_HASH = "acd843c08a7ede6419089a90a105d6fbe56220931b66deb6b231678bdebe43cf"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorizedKeys.js","sourceRoot":"","sources":["authorizedKeys.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from \"crypto\";\nimport fs from \"fs/promises\";\nimport path from \"path\";\n\nexport function normalizeKeys(contents: string) {\n    return contents.split(\"\\n\").map(line => line.trim()).filter(line => line && !line.startsWith(\"#\"));\n}\n\n/** The fingerprint ssh itself reports for a key, which is what the sshd log names and therefore\n    what a revocation is keyed by. Returns \"\" for a line that holds no key. */\nexport function keyFingerprint(keyLine: string) {\n    let parts = keyLine.trim().split(/\\s+/);\n    let typeIndex = parts.findIndex(part => /^(ssh-|ecdsa-|sk-)/.test(part));\n    let blob = typeIndex >= 0 && parts[typeIndex + 1] || \"\";\n    if (!blob) {\n        return \"\";\n    }\n    return \"SHA256:\" + crypto.createHash(\"sha256\").update(Buffer.from(blob, \"base64\")).digest(\"base64\").replace(/=+$/, \"\");\n}\n\nexport const NO_RESTRICTION = \"ANY ADDRESS (no from= restriction)\";\n\n/** The addresses a key may be used from, one by one, or undefined when the key carries no from=\n    at all. Undefined and an empty list are very different things, so they stay distinguishable. */\nexport function keyRestrictionList(keyLine: string) {\n    let match = keyLine.match(/from=\"([^\"]*)\"/);\n    if (!match) {\n        return undefined;\n    }\n    return match[1].split(\",\").map(entry => entry.trim()).filter(entry => entry);\n}\n\n/** The addresses a key may be used from, which is the part of an authorized_keys line that\n    decides how much a stolen key is worth. A key with no restriction says so loudly. */\nexport function keyRestriction(keyLine: string) {\n    let list = keyRestrictionList(keyLine);\n    if (!list) {\n        return NO_RESTRICTION;\n    }\n    return list.join(\",\");\n}\n\n/** Enough to recognise whose key this is without printing the whole blob. */\nexport function summarizeKey(keyLine: string) {\n    let parts = keyLine.trim().split(/\\s+/);\n    let typeIndex = parts.findIndex(part => /^(ssh-|ecdsa-|sk-)/.test(part));\n    if (typeIndex < 0) {\n        return keyLine.slice(0, 60);\n    }\n    let type = parts[typeIndex];\n    let blob = parts[typeIndex + 1] || \"\";\n    let comment = parts.slice(typeIndex + 2).join(\" \");\n    return `${type} ...${blob.slice(-12)}${comment && ` ${comment}` || \"\"}`;\n}\n\n/** What a set of keys has to satisfy before it is worth signing, as a list of complaints.\n\n    Every key needs a from=, because an unrestricted key can never be caught being used from the\n    wrong place, and being caught is the only thing that triggers a revocation.\n\n    No two keys may allow the same addresses, because that is one person holding two keys: revoking\n    one of them leaves the other working, so the revocation achieves nothing. */\nexport function findKeyProblems(keys: string[]) {\n    let problems: string[] = [];\n    let byRestriction = new Map<string, string[]>();\n    for (let key of keys) {\n        let restriction = keyRestrictionList(key);\n        if (!restriction) {\n            problems.push(`no from= restriction, so it can be used from anywhere:\\n      ${summarizeKey(key)}`);\n            continue;\n        }\n        // Sorted, so the same addresses written in a different order still count as the same.\n        let identity = [...restriction].sort().join(\",\");\n        byRestriction.set(identity, [...(byRestriction.get(identity) || []), key]);\n    }\n    for (let [restriction, sharing] of byRestriction) {\n        if (sharing.length < 2) {\n            continue;\n        }\n        problems.push(\n            `${sharing.length} keys allow exactly the same addresses (${restriction}), which is one`\n            + ` person holding more than one key:\\n`\n            + sharing.map(key => `      ${summarizeKey(key)}`).join(\"\\n\")\n        );\n    }\n    return problems;\n}\n\n/** Reads the authorized keys a repo checkout wants applied. Prefers a top level authorized_keys\n    file and otherwise concatenates every .pub at the top level. */\nexport async function readRepoKeys(repoPath: string) {\n    let combinedPath = path.join(repoPath, \"authorized_keys\");\n    let entries = await fs.readdir(repoPath);\n    if (entries.includes(\"authorized_keys\")) {\n        return normalizeKeys(await fs.readFile(combinedPath, \"utf8\"));\n    }\n    let pubFiles = entries.filter(name => name.endsWith(\".pub\")).sort();\n    if (!pubFiles.length) {\n        throw new Error(`Expected authorized_keys or at least one .pub file in ${repoPath}, found neither`);\n    }\n    let keys: string[] = [];\n    for (let name of pubFiles) {\n        keys.push(...normalizeKeys(await fs.readFile(path.join(repoPath, name), \"utf8\")));\n    }\n    return keys;\n}\n"]}
+ /* _JS_SOURCE_HASH = "a5147a2eb954468a9ddfcac36189a744f5b17f944d7e837ce0a525c780093a26"; */