+ * after:
+ *
+ *
+ */
+
+/* eslint no-console: ["off"] */
+
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+// Base directory of snackbarjs source
+const filePath = join(process.cwd(), "node_modules/snackbarjs/src/snackbar.js");
+
+const content = readFileSync(filePath, "utf8");
+
+// Replace self-closing div with standard opening div
+const updated = content.replace(
+ /
/g,
+ "
"
+);
+
+writeFileSync(filePath, updated, "utf8");
diff --git a/src/core/config/scripts/generateOpsIndex.mjs b/src/core/config/scripts/generateOpsIndex.mjs
index 9b9d5ddf..642e5820 100644
--- a/src/core/config/scripts/generateOpsIndex.mjs
+++ b/src/core/config/scripts/generateOpsIndex.mjs
@@ -30,12 +30,12 @@ fs.readdirSync(path.join(dir, "../operations")).forEach(file => {
// Construct index file
let code = `/**
-* THIS FILE IS AUTOMATICALLY GENERATED BY src/core/config/scripts/generateOpsIndex.mjs
-*
-* @author n1474335 [n1474335@gmail.com]
-* @copyright Crown Copyright ${new Date().getUTCFullYear()}
-* @license Apache-2.0
-*/
+ * THIS FILE IS AUTOMATICALLY GENERATED BY src/core/config/scripts/generateOpsIndex.mjs
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright ${new Date().getUTCFullYear()}
+ * @license Apache-2.0
+ */
`;
opObjs.forEach(obj => {
diff --git a/src/core/config/scripts/newMinorVersion.mjs b/src/core/config/scripts/newMinorVersion.mjs
index adfdf6f7..d22ef43b 100644
--- a/src/core/config/scripts/newMinorVersion.mjs
+++ b/src/core/config/scripts/newMinorVersion.mjs
@@ -7,138 +7,197 @@
*/
/* eslint no-console: ["off"] */
+/* eslint jsdoc/require-jsdoc: ["off"] */
-import prompt from "prompt";
-import colors from "colors";
import path from "path";
-import fs from "fs";
+import fs from "fs";
import process from "process";
+import { execSync } from "child_process";
-const dir = path.join(process.cwd() + "/src/core/config/");
-if (!fs.existsSync(dir)) {
- console.log("\nCWD: " + process.cwd());
- console.log("Error: newMinorVersion.mjs should be run from the project root");
- console.log("Example> node --experimental-modules src/core/config/scripts/newMinorVersion.mjs");
- process.exit(1);
-}
+const ignoredAuthors = ["github-advanced-security[bot]", "dependabot[bot]"];
-let changelogData = fs.readFileSync(path.join(process.cwd(), "CHANGELOG.md"), "utf8");
-const lastVersion = changelogData.match(/## Details\s+### \[(\d+)\.(\d+)\.(\d+)\]/);
-const newVersion = [
- parseInt(lastVersion[1], 10),
- parseInt(lastVersion[2], 10) + 1,
- 0
-];
+async function main() {
+ const dir = path.join(process.cwd() + "/src/core/config/");
+ if (!fs.existsSync(dir)) {
+ console.log("\nCWD: " + process.cwd());
+ console.log(
+ "Error: newMinorVersion.mjs should be run from the project root",
+ );
+ console.log(
+ "Example> node --experimental-modules src/core/config/scripts/newMinorVersion.mjs",
+ );
+ process.exit(1);
+ }
-let knownContributors = changelogData.match(/^\[@([^\]]+)\]/gm);
-knownContributors = knownContributors.map(c => c.slice(2, -1));
+ let changelogData = fs.readFileSync(
+ path.join(process.cwd(), "CHANGELOG.md"),
+ "utf8",
+ );
+ const lastVersion = changelogData.match(
+ /## Details\s+### \[(\d+)\.(\d+)\.(\d+)\]/,
+ );
+ const newVersion = [
+ parseInt(lastVersion[1], 10),
+ parseInt(lastVersion[2], 10) + 1,
+ 0,
+ ];
-const date = (new Date()).toISOString().split("T")[0];
+ let knownContributors = changelogData.match(/^\[@([^\]]+)\]/gm);
+ knownContributors = knownContributors.map((c) => c.slice(2, -1));
-const schema = {
- properties: {
- message: {
- description: "A short but descriptive summary of a feature in this version",
- example: "Added 'Op name' operation",
- prompt: "Feature description",
- type: "string",
- required: true,
+ const date = new Date().toISOString().split("T")[0];
+
+ const lastVersionSha = execSync(
+ `git rev-list -n 1 v${lastVersion[1]}.${lastVersion[2]}.${lastVersion[3]}`,
+ {
+ encoding: "utf8",
},
- author: {
- description: "The author of the feature (only one supported, edit manually to add more)",
- example: "n1474335",
- prompt: "Author",
- type: "string",
- default: "n1474335"
- },
- id: {
- description: "The PR number or full commit hash for this feature.",
- example: "1200",
- prompt: "Pull request or commit ID",
- type: "string"
- },
- another: {
- description: "y/n",
- example: "y",
- prompt: "Add another feature?",
- type: "string",
- pattern: /^[yn]$/,
+ ).trim();
+ if (lastVersionSha.length !== 40) {
+ throw new Error(
+ `Unexpected output from git rev-list: ${lastVersionSha}`,
+ );
+ }
+
+ const features = [];
+
+ const commits = await (
+ await fetch(`https://api.github.com/repos/gchq/cyberchef/commits`)
+ ).json();
+ let foundLast = false;
+ for (const commit of commits) {
+ if (commit.sha === lastVersionSha) {
+ foundLast = true;
+ break;
+ } else {
+ const feature = {
+ message: "",
+ authors: [],
+ id: "",
+ };
+
+ const msgparts = commit.commit.message.split("\n\n");
+ feature.message = msgparts[0];
+ const prIdMatch = feature.message.match(/\(#(\d+)\)$/);
+ if (prIdMatch !== null) {
+ feature.message = feature.message
+ .replace(prIdMatch[0], "")
+ .trim();
+ feature.id = prIdMatch[1];
+ }
+
+ if (!ignoredAuthors.includes(commit.author.login)) {
+ feature.authors.push(commit.author.login);
+ }
+
+ if (msgparts.length > 1) {
+ msgparts[1]
+ .split("\n")
+ .filter((line) => line.startsWith("Co-authored-by: "))
+ .forEach((line) => {
+ let coAuthor = line.slice("Co-authored-by: ".length);
+ if (coAuthor.indexOf(">") !== -1) {
+ const email = coAuthor.slice(
+ coAuthor.indexOf("<") + 1,
+ coAuthor.indexOf(">"),
+ );
+ if (email.endsWith("@users.noreply.github.com")) {
+ coAuthor = email.slice(
+ email.indexOf("+") + 1,
+ -"@users.noreply.github.com".length,
+ );
+ } else {
+ throw new Error(
+ "Could not get ID of co-author: " +
+ coAuthor,
+ );
+ }
+ } else {
+ throw new Error(
+ "Could not get email of co-author: " + coAuthor,
+ );
+ }
+ if (!ignoredAuthors.includes(coAuthor)) {
+ feature.authors.push(coAuthor);
+ }
+ });
+ }
+
+ features.push(feature);
}
}
-};
+ if (!foundLast) {
+ throw new Error(
+ `Could not find last version commit: ${lastVersionSha} - need to add paging functionality`,
+ );
+ }
-// Build schema
-for (const prop in schema.properties) {
- const p = schema.properties[prop];
- p.description = "\n" + colors.white(p.description) + colors.cyan("\nExample: " + p.example) + "\n" + colors.green(p.prompt);
-}
+ let message = `### [${newVersion[0]}.${newVersion[1]}.${newVersion[2]}] - ${date}\n`;
-prompt.message = "";
-prompt.delimiter = ":".green;
+ const authors = [];
+ const prIDs = [];
+ const commitIDs = [];
-const features = [];
-const authors = [];
-const prIDs = [];
-const commitIDs = [];
+ features.forEach((feature) => {
+ const id =
+ feature.id.length > 10 ? feature.id.slice(0, 7) : "#" + feature.id;
+ message += `- ${feature.message} ${feature.authors.map((a) => `[@${a}]`).join(" ")} | [${id}]\n`;
-prompt.start();
+ feature.authors.forEach((author) => {
+ if (!knownContributors.includes(author)) {
+ knownContributors.push(author);
+ authors.push(`[@${author}]: https://github.com/${author}`);
+ }
+ });
-const getFeature = function() {
- prompt.get(schema, (err, result) => {
- if (err) {
- console.log("\nExiting script.");
- process.exit(0);
- }
-
- features.push(result);
-
- if (result.another === "y") {
- getFeature();
+ if (feature.id.length > 10) {
+ commitIDs.push(
+ `[${id}]: https://github.com/gchq/CyberChef/commit/${feature.id}`,
+ );
} else {
- let message = `### [${newVersion[0]}.${newVersion[1]}.${newVersion[2]}] - ${date}\n`;
-
- features.forEach(feature => {
- const id = feature.id.length > 10 ? feature.id.slice(0, 7) : "#" + feature.id;
- message += `- ${feature.message} [@${feature.author}] | [${id}]\n`;
-
- if (!knownContributors.includes(feature.author)) {
- authors.push(`[@${feature.author}]: https://github.com/${feature.author}`);
- }
-
- if (feature.id.length > 10) {
- commitIDs.push(`[${id}]: https://github.com/gchq/CyberChef/commit/${feature.id}`);
- } else {
- prIDs.push(`[#${feature.id}]: https://github.com/gchq/CyberChef/pull/${feature.id}`);
- }
- });
-
- // Message
- changelogData = changelogData.replace(/## Details\n\n/, "## Details\n\n" + message + "\n");
-
- // Tag
- const newTag = `[${newVersion[0]}.${newVersion[1]}.${newVersion[2]}]: https://github.com/gchq/CyberChef/releases/tag/v${newVersion[0]}.${newVersion[1]}.${newVersion[2]}\n`;
- changelogData = changelogData.replace(/\n\n(\[\d+\.\d+\.\d+\]: https)/, "\n\n" + newTag + "$1");
-
- // Author
- authors.forEach(author => {
- changelogData = changelogData.replace(/(\n\[@[^\]]+\]: https:\/\/github\.com\/[^\n]+\n)\n/, "$1" + author + "\n\n");
- });
-
- // Commit IDs
- commitIDs.forEach(commitID => {
- changelogData = changelogData.replace(/(\n\[[^\].]+\]: https:\/\/github.com\/gchq\/CyberChef\/commit\/[^\n]+\n)\n/, "$1" + commitID + "\n\n");
- });
-
- // PR IDs
- prIDs.forEach(prID => {
- changelogData = changelogData.replace(/(\n\[#[^\]]+\]: https:\/\/github.com\/gchq\/CyberChef\/pull\/[^\n]+\n)\n*$/, "$1" + prID + "\n\n");
- });
-
- fs.writeFileSync(path.join(process.cwd(), "CHANGELOG.md"), changelogData);
-
- console.log("Written CHANGELOG.md");
+ prIDs.push(
+ `[#${feature.id}]: https://github.com/gchq/CyberChef/pull/${feature.id}`,
+ );
}
});
-};
-getFeature();
+ // Message
+ changelogData = changelogData.replace(
+ /## Details\n\n/,
+ "## Details\n\n" + message + "\n",
+ );
+
+ // Tag
+ const newTag = `[${newVersion[0]}.${newVersion[1]}.${newVersion[2]}]: https://github.com/gchq/CyberChef/releases/tag/v${newVersion[0]}.${newVersion[1]}.${newVersion[2]}\n`;
+ changelogData = changelogData.replace(
+ /\n\n(\[\d+\.\d+\.\d+\]: https)/,
+ "\n\n" + newTag + "$1",
+ );
+
+ // Author
+ authors.forEach((author) => {
+ changelogData = changelogData.replace(
+ /(\n\[@[^\]]+\]: https:\/\/github\.com\/[^\n]+\n)\n/,
+ "$1" + author + "\n\n",
+ );
+ });
+
+ // Commit IDs
+ commitIDs.forEach((commitID) => {
+ changelogData = changelogData.replace(
+ /(\n\[[^\].]+\]: https:\/\/github.com\/gchq\/CyberChef\/commit\/[^\n]+\n)\n/,
+ "$1" + commitID + "\n\n",
+ );
+ });
+
+ // PR IDs
+ prIDs.forEach((prID) => {
+ changelogData = changelogData.replace(
+ /(\n\[#[^\]]+\]: https:\/\/github.com\/gchq\/CyberChef\/(?:pull|issues)\/[^\n]+\n)\n*$/,
+ "$1" + prID + "\n\n",
+ );
+ });
+
+ fs.writeFileSync(path.join(process.cwd(), "CHANGELOG.md"), changelogData);
+}
+main().catch(console.error);
diff --git a/src/core/config/scripts/newOperation.mjs b/src/core/config/scripts/newOperation.mjs
index 2bcc074f..27e39741 100644
--- a/src/core/config/scripts/newOperation.mjs
+++ b/src/core/config/scripts/newOperation.mjs
@@ -191,7 +191,7 @@ class ${moduleName} extends Operation {
this.name = "${result.opName}";
this.module = "${result.module}";
this.description = "${(new EscapeString).run(result.description, ["Special chars", "Double"])}";
- this.infoURL = "${result.infoURL}";
+ this.infoURL = "${result.infoURL}"; // Usually a Wikipedia link. Remember to remove localisation (i.e. https://wikipedia.org/etc rather than https://en.wikipedia.org/etc)
this.inputType = "${result.inputType}";
this.outputType = "${result.outputType}";
this.args = [
diff --git a/src/core/dishTypes/DishBigNumber.mjs b/src/core/dishTypes/DishBigNumber.mjs
index d6f67698..3bb8122c 100644
--- a/src/core/dishTypes/DishBigNumber.mjs
+++ b/src/core/dishTypes/DishBigNumber.mjs
@@ -24,12 +24,11 @@ class DishBigNumber extends DishType {
/**
* convert the given value from a ArrayBuffer
- * @param {boolean} notUTF8
*/
- static fromArrayBuffer(notUTF8) {
+ static fromArrayBuffer() {
DishBigNumber.checkForValue(this.value);
try {
- this.value = new BigNumber(Utils.arrayBufferToStr(this.value, !notUTF8));
+ this.value = new BigNumber(Utils.arrayBufferToStr(this.value));
} catch (err) {
this.value = new BigNumber(NaN);
}
diff --git a/src/core/dishTypes/DishJSON.mjs b/src/core/dishTypes/DishJSON.mjs
index 703b0980..e1b32d64 100644
--- a/src/core/dishTypes/DishJSON.mjs
+++ b/src/core/dishTypes/DishJSON.mjs
@@ -22,11 +22,10 @@ class DishJSON extends DishType {
/**
* convert the given value from a ArrayBuffer
- * @param {boolean} notUTF8
*/
- static fromArrayBuffer(notUTF8) {
+ static fromArrayBuffer() {
DishJSON.checkForValue(this.value);
- this.value = JSON.parse(Utils.arrayBufferToStr(this.value, !notUTF8));
+ this.value = JSON.parse(Utils.arrayBufferToStr(this.value));
}
}
diff --git a/src/core/dishTypes/DishNumber.mjs b/src/core/dishTypes/DishNumber.mjs
index 8769a69a..e3ea31b8 100644
--- a/src/core/dishTypes/DishNumber.mjs
+++ b/src/core/dishTypes/DishNumber.mjs
@@ -23,11 +23,10 @@ class DishNumber extends DishType {
/**
* convert the given value from a ArrayBuffer
- * @param {boolean} notUTF8
*/
- static fromArrayBuffer(notUTF8) {
+ static fromArrayBuffer() {
DishNumber.checkForValue(this.value);
- this.value = this.value ? parseFloat(Utils.arrayBufferToStr(this.value, !notUTF8)) : 0;
+ this.value = this.value ? parseFloat(Utils.arrayBufferToStr(this.value)) : 0;
}
}
diff --git a/src/core/dishTypes/DishString.mjs b/src/core/dishTypes/DishString.mjs
index d7768859..7de8810d 100644
--- a/src/core/dishTypes/DishString.mjs
+++ b/src/core/dishTypes/DishString.mjs
@@ -23,11 +23,10 @@ class DishString extends DishType {
/**
* convert the given value from a ArrayBuffer
- * @param {boolean} notUTF8
*/
- static fromArrayBuffer(notUTF8) {
+ static fromArrayBuffer() {
DishString.checkForValue(this.value);
- this.value = this.value ? Utils.arrayBufferToStr(this.value, !notUTF8) : "";
+ this.value = this.value ? Utils.arrayBufferToStr(this.value) : "";
}
}
diff --git a/src/core/dishTypes/DishType.mjs b/src/core/dishTypes/DishType.mjs
index 849b5756..d89e3c0b 100644
--- a/src/core/dishTypes/DishType.mjs
+++ b/src/core/dishTypes/DishType.mjs
@@ -29,9 +29,8 @@ class DishType {
/**
* convert the given value from a ArrayBuffer
- * @param {boolean} notUTF8
*/
- static fromArrayBuffer(notUTF8=undefined) {
+ static fromArrayBuffer() {
throw new Error("fromArrayBuffer has not been implemented");
}
}
diff --git a/src/core/lib/AudioBytes.mjs b/src/core/lib/AudioBytes.mjs
new file mode 100644
index 00000000..9a433fcd
--- /dev/null
+++ b/src/core/lib/AudioBytes.mjs
@@ -0,0 +1,103 @@
+/**
+ * Byte-reading and text-decoding utilities for audio metadata parsing.
+ *
+ * @author d0s1nt [d0s1nt@cyberchefaudio]
+ * @copyright Crown Copyright 2025
+ * @license Apache-2.0
+ */
+
+/** @returns {string} 4-byte ASCII at offset, or "" if out of bounds. */
+export function ascii4(b, off) {
+ if (off + 4 > b.length) return "";
+ return String.fromCharCode(b[off], b[off + 1], b[off + 2], b[off + 3]);
+}
+
+/** @returns {number} Byte offset of ASCII needle `s`, or -1. */
+export function indexOfAscii(b, s, start, end) {
+ const limit = Math.max(0, Math.min(end, b.length) - s.length);
+ for (let i = start; i <= limit; i++) {
+ let ok = true;
+ for (let j = 0; j < s.length; j++) {
+ if (b[i + j] !== s.charCodeAt(j)) {
+ ok = false;
+ break;
+ }
+ }
+ if (ok) return i;
+ }
+ return -1;
+}
+
+/** @returns {number} Unsigned 32-bit big-endian read. */
+export function u32be(bytes, off) {
+ return ((bytes[off] << 24) >>> 0) | (bytes[off + 1] << 16) | (bytes[off + 2] << 8) | bytes[off + 3];
+}
+
+/** @returns {number} Unsigned 32-bit little-endian read. */
+export function u32le(bytes, off) {
+ return (bytes[off] | (bytes[off + 1] << 8) | (bytes[off + 2] << 16) | (bytes[off + 3] << 24)) >>> 0;
+}
+
+/** @returns {number} Unsigned 16-bit little-endian read. */
+export function u16le(bytes, off) {
+ return bytes[off] | (bytes[off + 1] << 8);
+}
+
+/** @returns {BigInt} Unsigned 64-bit little-endian read. */
+export function u64le(bytes, off) {
+ return BigInt(u32le(bytes, off)) | (BigInt(u32le(bytes, off + 4)) << 32n);
+}
+
+/** @returns {number} Decoded ID3v2 synchsafe integer from four 7-bit bytes. */
+export function synchsafeToInt(b0, b1, b2, b3) {
+ return ((b0 & 0x7f) << 21) | ((b1 & 0x7f) << 14) | ((b2 & 0x7f) << 7) | (b3 & 0x7f);
+}
+
+/** @returns {string} Decoded UTF-16LE byte range, nulls stripped. */
+export function decodeUtf16LE(b, off, len) {
+ if (len <= 0 || off + len > b.length) return "";
+ try {
+ return new TextDecoder("utf-16le").decode(b.slice(off, off + len)).replace(/\u0000/g, "").trim();
+ } catch {
+ return "";
+ }
+}
+
+/** @returns {{valueBytes: Uint8Array, next: number}} Bytes until null terminator, UTF-16 aware. */
+export function readNullTerminated(bytes, start, encoding) {
+ const isUtf16 = encoding === 1 || encoding === 2;
+ if (!isUtf16) {
+ let i = start;
+ while (i < bytes.length && bytes[i] !== 0x00) i++;
+ return { valueBytes: bytes.slice(start, i), next: i + 1 };
+ }
+ let i = start;
+ while (i + 1 < bytes.length && !(bytes[i] === 0x00 && bytes[i + 1] === 0x00)) i += 2;
+ return { valueBytes: bytes.slice(start, i), next: i + 2 };
+}
+
+const ID3_ENCODINGS = ["iso-8859-1", "utf-16", "utf-16be", "utf-8"];
+
+/** @returns {string} Text decoded using ID3v2 encoding byte (0=latin1, 1=utf16, 2=utf16be, 3=utf8). */
+export function decodeText(bytes, encoding) {
+ if (!bytes || bytes.length === 0) return "";
+ try {
+ return new TextDecoder(ID3_ENCODINGS[encoding] || "utf-16").decode(bytes);
+ } catch {
+ return safeUtf8(bytes);
+ }
+}
+
+/** @returns {string} UTF-8 decode with replacement (never throws). */
+export function safeUtf8(bytes) {
+ try {
+ return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+ } catch {
+ return "";
+ }
+}
+
+/** @returns {string} ISO-8859-1 decode, nulls stripped, trimmed. */
+export function decodeLatin1Trim(bytes) {
+ return decodeText(bytes, 0).replace(/\u0000/g, "").trim();
+}
diff --git a/src/core/lib/AudioMetaSchema.mjs b/src/core/lib/AudioMetaSchema.mjs
new file mode 100644
index 00000000..c46445be
--- /dev/null
+++ b/src/core/lib/AudioMetaSchema.mjs
@@ -0,0 +1,82 @@
+/**
+ * Report skeleton and container detection for audio metadata extraction.
+ *
+ * @author d0s1nt [d0s1nt@cyberchefaudio]
+ * @copyright Crown Copyright 2025
+ * @license Apache-2.0
+ */
+
+/* eslint-disable camelcase */
+
+import { ascii4, indexOfAscii } from "./AudioBytes.mjs";
+
+/** Builds the empty report skeleton ready for a format parser to populate. */
+export function makeEmptyReport(filename, byteLength, container) {
+ return {
+ schema_version: "audio-meta-1.0",
+ artifact: {
+ filename,
+ byte_length: byteLength,
+ container: { type: container.type, brand: container.brand || null, mime: container.mime || null },
+ },
+ detections: { metadata_systems: [], provenance_systems: [] },
+ tags: {
+ common: {
+ title: null, artist: null, album: null, date: null, track: null,
+ genre: null, comment: null, composer: null, copyright: null, language: null,
+ },
+ raw: {},
+ },
+ embedded: [],
+ provenance: {
+ c2pa: {
+ present: false,
+ embedding: [],
+ manifest_store: { active_manifest_urn: null, instance_id: null, claim_generator: null },
+ assertions: [],
+ signature: {
+ algorithm: null, signing_time: null,
+ certificate: { subject_cn: null, issuer_cn: null, serial_number: null },
+ },
+ validation: { validation_state: "Unknown", reasons: [], details_raw: null },
+ },
+ },
+ errors: [],
+ };
+}
+
+/** Detects the audio container format from magic bytes. */
+export function sniffContainer(b) {
+ if (b.length >= 3 && b[0] === 0x49 && b[1] === 0x44 && b[2] === 0x33)
+ return { type: "mp3", mime: "audio/mpeg" };
+ if (b.length >= 2 && b[0] === 0xff && (b[1] & 0xe0) === 0xe0) {
+ if ((b[1] & 0x06) === 0x00) return { type: "aac", mime: "audio/aac" };
+ return { type: "mp3", mime: "audio/mpeg" };
+ }
+ if (b.length >= 8 && b[0] === 0x0b && b[1] === 0x77)
+ return { type: "ac3", mime: "audio/ac3" };
+ if (b.length >= 16 &&
+ b[0] === 0x30 && b[1] === 0x26 && b[2] === 0xb2 && b[3] === 0x75 &&
+ b[4] === 0x8e && b[5] === 0x66 && b[6] === 0xcf && b[7] === 0x11)
+ return { type: "wma", mime: "audio/x-ms-wma" };
+ if (b.length >= 12 && ascii4(b, 0) === "RIFF" && ascii4(b, 8) === "WAVE")
+ return { type: "wav", mime: "audio/wav" };
+ if (b.length >= 12 && ascii4(b, 0) === "BW64" && ascii4(b, 8) === "WAVE")
+ return { type: "bw64", mime: "audio/wav" };
+ if (b.length >= 4 && ascii4(b, 0) === "fLaC")
+ return { type: "flac", mime: "audio/flac" };
+ if (b.length >= 4 && ascii4(b, 0) === "OggS") {
+ const idx = indexOfAscii(b, "OpusHead", 0, Math.min(b.length, 65536));
+ return idx >= 0 ? { type: "opus", mime: "audio/ogg" } : { type: "ogg", mime: "audio/ogg" };
+ }
+ if (b.length >= 12 && ascii4(b, 4) === "ftyp") {
+ const brand = ascii4(b, 8);
+ const isM4A = brand === "M4A " || brand === "M4B " || brand === "M4P ";
+ return { type: isM4A ? "m4a" : "mp4", mime: isM4A ? "audio/mp4" : "video/mp4", brand };
+ }
+ if (b.length >= 12 && ascii4(b, 0) === "FORM") {
+ const formType = ascii4(b, 8);
+ if (formType === "AIFF" || formType === "AIFC") return { type: "aiff", mime: "audio/aiff", brand: formType };
+ }
+ return { type: "unknown", mime: null };
+}
diff --git a/src/core/lib/AudioParsers.mjs b/src/core/lib/AudioParsers.mjs
new file mode 100644
index 00000000..0e564b04
--- /dev/null
+++ b/src/core/lib/AudioParsers.mjs
@@ -0,0 +1,630 @@
+/**
+ * Format-specific audio metadata parsers.
+ *
+ * @author d0s1nt [d0s1nt@cyberchefaudio]
+ * @copyright Crown Copyright 2025
+ * @license Apache-2.0
+ */
+
+/* eslint-disable camelcase */
+
+import {
+ ascii4, indexOfAscii,
+ u32be, u32le, u16le, u64le, synchsafeToInt,
+ decodeUtf16LE, readNullTerminated, decodeText,
+ safeUtf8, decodeLatin1Trim,
+} from "./AudioBytes.mjs";
+
+/** Parses MP3 metadata: ID3v2 frames, ID3v1 footer, APEv2 tags. */
+export function parseMp3(b, report) {
+ processId3v2(b, report);
+ processId3v1(b, report);
+
+ const ape = parseApeV2BestEffort(b);
+ if (ape) {
+ report.detections.metadata_systems.push("apev2");
+ report.tags.raw.apev2 = ape;
+ }
+}
+
+/** Iterates ID3v2 frames and populates the report. */
+function processId3v2(b, report) {
+ report.detections.metadata_systems.push("id3v2");
+
+ const id3 = parseId3v2(b);
+ report.tags.raw.id3v2 = id3 ? { header: id3.header, frames: [] } : null;
+
+ if (id3) {
+ for (const f of id3.frames) {
+ const entry = { id: f.id, size: f.size, description: ID3_FRAME_DESCRIPTIONS[f.id] || null };
+
+ if (f.id[0] === "T" && f.id !== "TXXX") {
+ const text = f.data?.length >= 1 ?
+ decodeText(f.data.slice(1), f.data[0]).replace(/\u0000/g, "").trim() :
+ "";
+ entry.decoded = text;
+ if (f.id === "TLEN") {
+ const ms = normalizeTlen(text);
+ if (ms !== null) entry.normalized_ms = ms;
+ }
+ mapCommonId3(report, f.id, text);
+ } else if (f.id === "TXXX") {
+ const txxx = decodeTxxx(f.data);
+ entry.decoded = txxx;
+ if (!report.tags.raw.id3v2.txxx) report.tags.raw.id3v2.txxx = [];
+ report.tags.raw.id3v2.txxx.push(txxx);
+ } else if (f.id === "COMM") {
+ const comm = decodeCommFrame(f.data);
+ entry.decoded = comm;
+ if (comm?.text && !report.tags.common.comment) report.tags.common.comment = comm.text;
+ } else if (f.id === "GEOB") {
+ processGeobFrame(f, entry, report);
+ }
+
+ report.tags.raw.id3v2.frames.push(entry);
+ }
+ } else {
+ report.detections.metadata_systems = report.detections.metadata_systems.filter((x) => x !== "id3v2");
+ }
+}
+
+/** Parses GEOB frame contents, populates entry, embedded objects, and C2PA provenance. */
+function processGeobFrame(f, entry, report) {
+ const d = f.data, enc = d[0];
+ let off = 1;
+ const mime = readNullTerminated(d, off, 0);
+ const mimeType = decodeLatin1Trim(mime.valueBytes);
+ off = mime.next;
+ const file = readNullTerminated(d, off, enc);
+ const filename = decodeText(file.valueBytes, enc).replace(/\u0000/g, "").trim();
+ off = file.next;
+ const desc = readNullTerminated(d, off, enc);
+ const description = decodeText(desc.valueBytes, enc).replace(/\u0000/g, "").trim();
+ off = desc.next;
+ const objLen = d.length - off;
+
+ entry.geob = { mimeType, filename, description, object_bytes: objLen };
+ const geobId = `geob_${report.embedded.filter((x) => x.source === "id3v2:GEOB").length}`;
+ report.embedded.push({
+ id: geobId, source: "id3v2:GEOB",
+ content_type: mimeType || null, byte_length: objLen,
+ description: description || null, filename: filename || null,
+ });
+
+ const mt = (mimeType || "").toLowerCase();
+ if (mt.includes("c2pa") || mt.includes("jumbf") || mt.includes("application/x-c2pa-manifest-store")) {
+ report.provenance.c2pa.present = true;
+ report.provenance.c2pa.embedding.push({
+ carrier: "id3v2:GEOB", content_type: mimeType || null, byte_length: objLen,
+ });
+ }
+}
+
+/** Processes the 128-byte ID3v1 footer tag. */
+function processId3v1(b, report) {
+ const id3v1 = parseId3v1(b);
+ if (!id3v1) return;
+
+ report.detections.metadata_systems.push("id3v1");
+ report.tags.raw.id3v1 = id3v1;
+ mapCommon(report, id3v1, ID3V1_TO_COMMON);
+}
+
+/** Parses WAV/BWF/BW64 RIFF chunks: LIST/INFO, bext, iXML, axml, ds64. */
+export function parseRiffWave(b, report, maxTextBytes) {
+ report.detections.metadata_systems.push("riff_info");
+
+ const chunks = enumerateChunks(b, 12, b.length, 50000);
+ const riff = { chunks: [], info: null, bext: null, ixml: null, axml: null, ds64: null };
+
+ const info = {};
+ for (const c of chunks) {
+ riff.chunks.push({ id: c.id, size: c.size, offset: c.dataOff });
+ processRiffChunk(b, c, riff, info, report, maxTextBytes);
+ }
+
+ riff.info = Object.keys(info).length ? info : null;
+ report.tags.raw.riff = riff;
+ if (riff.info) mapCommon(report, riff.info, RIFF_TO_COMMON);
+}
+
+/** Processes a single RIFF chunk, updating riff state and the report. */
+function processRiffChunk(b, c, riff, info, report, maxTextBytes) {
+ if (c.id === "ds64") {
+ riff.ds64 = { present: true, size: c.size };
+ if (!report.detections.metadata_systems.includes("bw64_ds64")) report.detections.metadata_systems.push("bw64_ds64");
+ if (report.artifact.container.type === "wav") report.artifact.container.type = "bw64";
+ }
+
+ if (c.id === "LIST" && ascii4(b, c.dataOff) === "INFO") {
+ for (const s of enumerateChunks(b, c.dataOff + 4, c.dataOff + c.size, 10000))
+ info[s.id] = decodeLatin1Trim(b.slice(s.dataOff, s.dataOff + s.size));
+ }
+
+ if (c.id === "bext") {
+ if (!report.detections.metadata_systems.includes("bwf_bext")) report.detections.metadata_systems.push("bwf_bext");
+ riff.bext = parseBext(b, c.dataOff, c.size);
+ }
+
+ if (c.id === "iXML" || c.id === "axml") {
+ const key = c.id === "iXML" ? "ixml" : "axml";
+ if (!report.detections.metadata_systems.includes(key)) report.detections.metadata_systems.push(key);
+ const payload = b.slice(c.dataOff, c.dataOff + c.size);
+ riff[key] = { xml: safeUtf8(payload.slice(0, Math.min(payload.length, maxTextBytes))), truncated: payload.length > maxTextBytes };
+ report.embedded.push({
+ id: `${key}_0`, source: `riff:${c.id}`, content_type: "application/xml",
+ byte_length: payload.length, description: `${c.id} chunk`, filename: null,
+ });
+ }
+}
+
+/** Parses FLAC metablocks: STREAMINFO, Vorbis Comment, PICTURE. */
+export function parseFlac(b, report, maxTextBytes) {
+ report.detections.metadata_systems.push("flac_metablocks");
+
+ const blocks = parseFlacMetaBlocks(b);
+ report.tags.raw.flac = { blocks: [] };
+
+ for (const blk of blocks) {
+ report.tags.raw.flac.blocks.push({ type: blk.typeName, length: blk.length });
+
+ if (blk.typeName === "VORBIS_COMMENT") {
+ if (!report.detections.metadata_systems.includes("vorbis_comments")) report.detections.metadata_systems.push("vorbis_comments");
+ const vc = parseVorbisComment(blk.data);
+ report.tags.raw.vorbis_comments = vc;
+ mapVorbisCommon(report, vc);
+ } else if (blk.typeName === "PICTURE") {
+ const pic = parseFlacPicture(blk.data, maxTextBytes);
+ report.embedded.push({
+ id: `cover_art_${report.embedded.filter((x) => x.id.startsWith("cover_art_")).length}`,
+ source: "flac:PICTURE", content_type: pic.mime || null,
+ byte_length: pic.dataLength, description: pic.description || null, filename: null,
+ });
+ }
+ }
+}
+
+/** Parses OGG/Opus Vorbis comments. */
+export function parseOgg(b, report) {
+ if (!report.detections.metadata_systems.includes("ogg_opus_tags")) report.detections.metadata_systems.push("ogg_opus_tags");
+
+ const scanEnd = Math.min(b.length, 1024 * 1024);
+ let tags = null;
+ const opusTagsIdx = indexOfAscii(b, "OpusTags", 0, scanEnd);
+ if (opusTagsIdx >= 0) {
+ report.artifact.container.type = "opus";
+ tags = parseVorbisComment(b.slice(opusTagsIdx + 8, scanEnd));
+ } else {
+ const vorbisIdx = indexOfAscii(b, "\x03vorbis", 0, scanEnd);
+ if (vorbisIdx >= 0) tags = parseVorbisComment(b.slice(vorbisIdx + 7, scanEnd));
+ }
+
+ report.tags.raw.ogg = { has_opustags: opusTagsIdx >= 0, has_vorbis_comment: !!tags };
+
+ if (tags) {
+ if (!report.detections.metadata_systems.includes("vorbis_comments")) report.detections.metadata_systems.push("vorbis_comments");
+ report.tags.raw.vorbis_comments = tags;
+ mapVorbisCommon(report, tags);
+ }
+}
+
+/** Best-effort top-level atom scan for MP4/M4A. */
+export function parseMp4BestEffort(b, report) {
+ report.detections.metadata_systems.push("mp4_atoms");
+ const atoms = [];
+
+ let off = 0;
+ while (off + 8 <= b.length && atoms.length < 2000) {
+ const size = u32be(b, off);
+ const type = ascii4(b, off + 4);
+ if (size < 8) break;
+ atoms.push({ type, size, offset: off });
+ off += size;
+ }
+
+ report.tags.raw.mp4 = {
+ top_level_atoms: atoms.slice(0, 200),
+ hints: {
+ hasMoov: atoms.some((a) => a.type === "moov"),
+ hasUdta: atoms.some((a) => a.type === "udta"),
+ hasMeta: atoms.some((a) => a.type === "meta"),
+ hasIlst: atoms.some((a) => a.type === "ilst"),
+ },
+ };
+}
+
+/** Best-effort AIFF/AIFC chunk scanning for NAME, AUTH, ANNO. */
+export function parseAiffBestEffort(b, report, maxTextBytes) {
+ report.detections.metadata_systems.push("aiff_chunks");
+ let off = 12;
+ const chunks = [];
+ while (off + 8 <= b.length && chunks.length < 2000) {
+ const id = ascii4(b, off);
+ const size = u32be(b, off + 4);
+ const dataOff = off + 8;
+ chunks.push({ id, size, offset: off });
+
+ if (["NAME", "AUTH", "ANNO", "(c) "].includes(id)) {
+ const txt = safeUtf8(b.slice(dataOff, dataOff + Math.min(size, maxTextBytes)));
+ if (!report.tags.raw.aiff) report.tags.raw.aiff = { chunks: [] };
+ report.tags.raw.aiff.chunks.push({ id, value: txt, truncated: size > maxTextBytes });
+ }
+
+ off = dataOff + size + (size % 2);
+ }
+
+ if (!report.tags.raw.aiff) report.tags.raw.aiff = {};
+ report.tags.raw.aiff.chunk_index = chunks.slice(0, 500);
+
+ const nameChunk = report.tags.raw.aiff?.chunks?.find((ch) => ch.id === "NAME")?.value;
+ if (nameChunk) report.tags.common.title = report.tags.common.title || nameChunk;
+}
+
+const AAC_SAMPLE_RATES = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+const AAC_PROFILES = ["Main", "LC", "SSR", "LTP"];
+const AAC_CHANNELS = ["defined in AOT", "mono", "stereo", "3.0", "4.0", "5.0", "5.1", "7.1"];
+
+/** Parses AAC ADTS frame header for audio parameters. */
+export function parseAacAdts(b, report) {
+ report.detections.metadata_systems.push("adts_header");
+ if (b.length < 7) return;
+
+ const id = (b[1] >> 3) & 0x01;
+ const profile = (b[2] >> 6) & 0x03;
+ const freqIdx = (b[2] >> 2) & 0x0f;
+ const chanCfg = ((b[2] & 0x01) << 2) | ((b[3] >> 6) & 0x03);
+
+ report.tags.raw.aac = {
+ mpeg_version: id === 1 ? "MPEG-2" : "MPEG-4",
+ profile: AAC_PROFILES[profile] || `Profile ${profile}`,
+ sample_rate: AAC_SAMPLE_RATES[freqIdx] || null,
+ sample_rate_index: freqIdx,
+ channel_configuration: chanCfg,
+ channel_description: AAC_CHANNELS[chanCfg] || null,
+ };
+}
+
+const AC3_SAMPLE_RATES = [48000, 44100, 32000];
+const AC3_BITRATES = [32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 448, 512, 576, 640];
+const AC3_ACMODES = [
+ "2.0 (Ch1+Ch2)", "1.0 (C)", "2.0 (L R)", "3.0 (L C R)",
+ "2.1 (L R S)", "3.1 (L C R S)", "2.2 (L R SL SR)", "3.2 (L C R SL SR)",
+];
+
+/** Parses AC3 (Dolby Digital) bitstream info. */
+export function parseAc3(b, report) {
+ report.detections.metadata_systems.push("ac3_bsi");
+ if (b.length < 8) return;
+
+ const fscod = (b[4] >> 6) & 0x03;
+ const frmsizecod = b[4] & 0x3f;
+ const bsid = (b[5] >> 3) & 0x1f;
+ const bsmod = b[5] & 0x07;
+ const acmod = (b[6] >> 5) & 0x07;
+
+ report.tags.raw.ac3 = {
+ sample_rate: AC3_SAMPLE_RATES[fscod] || null,
+ fscod,
+ bitrate_kbps: AC3_BITRATES[frmsizecod >> 1] || null,
+ frmsizecod, bsid, bsmod, acmod,
+ channel_layout: AC3_ACMODES[acmod] || null,
+ };
+}
+
+/** Parses WMA files (ASF container) for content description metadata. */
+export function parseWmaAsf(b, report) {
+ report.detections.metadata_systems.push("asf_header");
+ if (b.length < 30) return;
+
+ const headerSize = Number(u64le(b, 16));
+ const numObjects = u32le(b, 24);
+ const headerEnd = Math.min(b.length, headerSize);
+
+ const objects = [];
+ let off = 30;
+
+ for (let i = 0; i < numObjects && off + 24 <= headerEnd; i++) {
+ const guid4 = [b[off], b[off + 1], b[off + 2], b[off + 3]];
+ const objSize = Number(u64le(b, off + 16));
+ if (objSize < 24 || off + objSize > headerEnd) break;
+
+ const dataOff = off + 24;
+ const dataLen = objSize - 24;
+
+ if (guid4[0] === 0x33 && guid4[1] === 0x26 && guid4[2] === 0xb2 && guid4[3] === 0x75 && dataLen >= 10) {
+ const cd = parseAsfContentDescription(b, dataOff);
+ if (!report.detections.metadata_systems.includes("asf_content_desc"))
+ report.detections.metadata_systems.push("asf_content_desc");
+ if (!report.tags.raw.asf) report.tags.raw.asf = {};
+ report.tags.raw.asf.content_description = cd;
+ mapCommon(report, cd, ASF_CD_TO_COMMON);
+ }
+
+ if (guid4[0] === 0x40 && guid4[1] === 0xa4 && guid4[2] === 0xd0 && guid4[3] === 0xd2 && dataLen >= 2) {
+ const ext = parseAsfExtContentDescription(b, dataOff, dataOff + dataLen);
+ if (!report.detections.metadata_systems.includes("asf_ext_content_desc"))
+ report.detections.metadata_systems.push("asf_ext_content_desc");
+ if (!report.tags.raw.asf) report.tags.raw.asf = {};
+ report.tags.raw.asf.extended_content = ext;
+
+ const c = report.tags.common;
+ for (const d of ext) {
+ const field = WMA_TO_COMMON[(d.name || "").toUpperCase()];
+ if (field && d.value) c[field] = c[field] || d.value;
+ }
+ }
+
+ objects.push({ guid_prefix: guid4.map(x => x.toString(16).padStart(2, "0")).join(""), size: objSize });
+ off += objSize;
+ }
+
+ if (!report.tags.raw.asf) report.tags.raw.asf = {};
+ report.tags.raw.asf.header_objects = objects;
+}
+
+const ID3_FRAME_DESCRIPTIONS = {
+ TIT2: "Title/songname/content description", TPE1: "Lead performer(s)/Soloist(s)",
+ TRCK: "Track number/Position in set", TALB: "Album/Movie/Show title",
+ TDRC: "Recording time", TYER: "Year", TCON: "Content type",
+ TPE2: "Band/orchestra/accompaniment", TLEN: "Length (ms)", TCOM: "Composer",
+ COMM: "Comments", APIC: "Attached picture", GEOB: "General encapsulated object",
+ TXXX: "User defined text information frame", UFID: "Unique file identifier", PRIV: "Private frame",
+};
+
+const ID3_TO_COMMON = {
+ TIT2: "title", TPE1: "artist", TALB: "album", TDRC: "date", TYER: "date",
+ TRCK: "track", TCON: "genre", COMM: "comment", TCOM: "composer", TCOP: "copyright", TLAN: "language",
+};
+const VORBIS_TO_COMMON = {
+ TITLE: "title", ARTIST: "artist", ALBUM: "album", DATE: "date",
+ TRACKNUMBER: "track", GENRE: "genre", COMMENT: "comment", COMPOSER: "composer", LANGUAGE: "language",
+};
+const WMA_TO_COMMON = {
+ "WM/ALBUMTITLE": "album", "WM/GENRE": "genre", "WM/YEAR": "date",
+ "WM/TRACKNUMBER": "track", "WM/COMPOSER": "composer", "WM/LANGUAGE": "language",
+};
+const ID3V1_TO_COMMON = { title: "title", artist: "artist", album: "album", year: "date", comment: "comment", genre: "genre", track: "track" };
+const RIFF_TO_COMMON = { INAM: "title", IART: "artist", ICMT: "comment", IGNR: "genre", ICRD: "date", ICOP: "copyright" };
+const ASF_CD_TO_COMMON = { title: "title", author: "artist", copyright: "copyright", description: "comment" };
+
+/** Maps source object fields to the common tags layer via a mapping table. */
+function mapCommon(report, source, mapping) {
+ const c = report.tags.common;
+ for (const [sk, ck] of Object.entries(mapping))
+ c[ck] = c[ck] || source[sk] || null;
+}
+
+/** Maps an ID3v2 frame value to the common tags layer. */
+function mapCommonId3(report, frameId, text) {
+ const field = ID3_TO_COMMON[frameId];
+ if (field) report.tags.common[field] = report.tags.common[field] || text || null;
+}
+
+/** Decodes an ID3v2 COMM (Comments) frame. */
+function decodeCommFrame(data) {
+ if (!data || data.length < 5) return null;
+ const enc = data[0];
+ const language = String.fromCharCode(data[1], data[2], data[3]);
+ const { valueBytes: descBytes, next } = readNullTerminated(data, 4, enc);
+ const short_description = decodeText(descBytes, enc).replace(/\u0000/g, "").trim() || null;
+ const text = decodeText(data.slice(next), enc).replace(/\u0000/g, "").trim() || null;
+ return { language, short_description, text };
+}
+
+/** Normalizes TLEN to integer milliseconds. */
+function normalizeTlen(s) {
+ if (!s) return null;
+ if (/^\s*\d+\s*$/.test(s)) return parseInt(s.trim(), 10);
+ const f = Number(s);
+ if (Number.isFinite(f) && f > 0 && f < 100000) return Math.round(f * 1000);
+ return null;
+}
+
+/** Parses the ID3v2 tag header and frames. */
+function parseId3v2(mp3) {
+ if (mp3.length < 10 || mp3[0] !== 0x49 || mp3[1] !== 0x44 || mp3[2] !== 0x33) return null;
+
+ const major = mp3[3], minor = mp3[4], flags = mp3[5];
+ const tagSize = synchsafeToInt(mp3[6], mp3[7], mp3[8], mp3[9]);
+ let offset = 10;
+ const end = 10 + tagSize;
+
+ const frames = [];
+ while (offset + 10 <= end) {
+ const id = String.fromCharCode(mp3[offset], mp3[offset + 1], mp3[offset + 2], mp3[offset + 3]);
+ if (!/^[A-Z0-9]{4}$/.test(id)) break;
+ const size = major === 4 ?
+ synchsafeToInt(mp3[offset + 4], mp3[offset + 5], mp3[offset + 6], mp3[offset + 7]) :
+ u32be(mp3, offset + 4);
+ offset += 10;
+ if (size <= 0 || offset + size > mp3.length) break;
+ frames.push({ id, size, data: mp3.slice(offset, offset + size) });
+ offset += size;
+ }
+
+ return { header: { version: `${major}.${minor}`, flags, tag_size: tagSize }, frames };
+}
+
+/** Parses the 128-byte ID3v1 tag at the end of the file. */
+function parseId3v1(b) {
+ if (b.length < 128) return null;
+ const off = b.length - 128;
+ if (b[off] !== 0x54 || b[off + 1] !== 0x41 || b[off + 2] !== 0x47) return null;
+
+ let track = null;
+ if (b[off + 125] === 0x00 && b[off + 126] !== 0x00) track = String(b[off + 126]);
+
+ return {
+ title: decodeLatin1Trim(b.slice(off + 3, off + 33)),
+ artist: decodeLatin1Trim(b.slice(off + 33, off + 63)),
+ album: decodeLatin1Trim(b.slice(off + 63, off + 93)),
+ year: decodeLatin1Trim(b.slice(off + 93, off + 97)),
+ comment: decodeLatin1Trim(b.slice(off + 97, off + 127)),
+ track, genre: String(b[off + 127]),
+ };
+}
+
+/** Decodes an ID3v2 TXXX (user-defined text) frame. */
+function decodeTxxx(data) {
+ if (!data || data.length < 2) return null;
+ const enc = data[0];
+ const { valueBytes: descBytes, next } = readNullTerminated(data, 1, enc);
+ const desc = decodeText(descBytes, enc).replace(/\u0000/g, "").trim();
+ const val = decodeText(data.slice(next), enc).replace(/\u0000/g, "").trim();
+ return { description: desc || null, value: val || null };
+}
+
+/** Best-effort APEv2 tag parser scanning the last 32 KB. */
+function parseApeV2BestEffort(b) {
+ const scanStart = Math.max(0, b.length - 32768);
+ const idx = indexOfAscii(b, "APETAGEX", scanStart, b.length);
+ if (idx < 0) return null;
+ if (idx + 32 > b.length) return { present: true, warning: "APETAGEX found but footer truncated." };
+
+ const ver = u32le(b, idx + 8), size = u32le(b, idx + 12);
+ const count = u32le(b, idx + 16), flags = u32le(b, idx + 20);
+
+ const tagStart = idx + 32 - size;
+ if (tagStart < 0 || tagStart >= b.length)
+ return { present: true, version: ver, size, count, flags, warning: "APEv2 bounds invalid (non-standard placement)." };
+
+ const items = [];
+ let off = tagStart + 32;
+ const end = Math.min(b.length, idx);
+ while (off + 8 < end && items.length < 5000) {
+ const valueSize = u32le(b, off), itemFlags = u32le(b, off + 4);
+ off += 8;
+ let keyEnd = off;
+ while (keyEnd < end && b[keyEnd] !== 0x00) keyEnd++;
+ const key = decodeLatin1Trim(b.slice(off, keyEnd));
+ off = keyEnd + 1;
+ if (!key || off + valueSize > end) break;
+ const value = safeUtf8(b.slice(off, off + valueSize)).replace(/\u0000/g, "").trim();
+ off += valueSize;
+ items.push({ key, value, flags: itemFlags });
+ }
+
+ return { present: true, version: ver, size, count, flags, items };
+}
+
+/** Enumerates RIFF-style chunks (id + LE32 size) within a byte range, padding to even. */
+function enumerateChunks(b, start, end, maxCount) {
+ const chunks = [];
+ let off = start;
+ while (off + 8 <= end && chunks.length < maxCount) {
+ const id = ascii4(b, off);
+ const size = u32le(b, off + 4);
+ const dataOff = off + 8;
+ if (dataOff + size > end) break;
+ chunks.push({ id, size, dataOff });
+ off = dataOff + size + (size % 2);
+ }
+ return chunks;
+}
+
+/** Parses a BWF bext chunk. */
+function parseBext(b, off, size) {
+ const slice = b.slice(off, off + size);
+ const timeRefLow = u32le(slice, 338), timeRefHigh = u32le(slice, 342);
+ return {
+ description: decodeLatin1Trim(slice.slice(0, 256)) || null,
+ originator: decodeLatin1Trim(slice.slice(256, 288)) || null,
+ originator_reference: decodeLatin1Trim(slice.slice(288, 320)) || null,
+ origination_date: decodeLatin1Trim(slice.slice(320, 330)) || null,
+ origination_time: decodeLatin1Trim(slice.slice(330, 338)) || null,
+ time_reference_samples: ((BigInt(timeRefHigh) << 32n) | BigInt(timeRefLow)).toString(),
+ };
+}
+
+const FLAC_TYPE_NAMES = { 0: "STREAMINFO", 1: "PADDING", 2: "APPLICATION", 3: "SEEKTABLE", 4: "VORBIS_COMMENT", 5: "CUESHEET", 6: "PICTURE" };
+
+/** Parses FLAC metadata blocks following the "fLaC" marker. */
+function parseFlacMetaBlocks(b) {
+ const blocks = [];
+ let off = 4;
+ while (off + 4 <= b.length && blocks.length < 10000) {
+ const header = b[off];
+ const isLast = (header & 0x80) !== 0;
+ const type = header & 0x7f;
+ const len = (b[off + 1] << 16) | (b[off + 2] << 8) | b[off + 3];
+ off += 4;
+ if (off + len > b.length) break;
+ blocks.push({ type, typeName: FLAC_TYPE_NAMES[type] || `TYPE_${type}`, length: len, data: b.slice(off, off + len) });
+ off += len;
+ if (isLast) break;
+ }
+ return blocks;
+}
+
+/** Parses a Vorbis Comment block (used by FLAC and OGG). */
+function parseVorbisComment(buf) {
+ let off = 0;
+ const vendorLen = u32le(buf, off); off += 4;
+ if (off + vendorLen > buf.length) return { vendor: null, comments: [], warning: "vendor_len out of bounds" };
+ const vendor = safeUtf8(buf.slice(off, off + vendorLen)); off += vendorLen;
+ const count = u32le(buf, off); off += 4;
+
+ const comments = [];
+ for (let i = 0; i < count && off + 4 <= buf.length && comments.length < 20000; i++) {
+ const l = u32le(buf, off); off += 4;
+ if (off + l > buf.length) break;
+ const s = safeUtf8(buf.slice(off, off + l)); off += l;
+ const eq = s.indexOf("=");
+ if (eq > 0) comments.push({ key: s.slice(0, eq).toUpperCase(), value: s.slice(eq + 1) });
+ }
+ return { vendor, comments };
+}
+
+/** Maps Vorbis Comment fields to the common tags layer. */
+function mapVorbisCommon(report, vc) {
+ const c = report.tags.common;
+ for (const [vk, ck] of Object.entries(VORBIS_TO_COMMON))
+ c[ck] = c[ck] || vc.comments?.find((x) => x.key === vk)?.value || null;
+}
+
+/** Parses a FLAC PICTURE metadata block (extracts mime, description, data length). */
+function parseFlacPicture(data, maxTextBytes) {
+ let off = 4;
+ const mimeLen = u32be(data, off); off += 4;
+ const mime = safeUtf8(data.slice(off, off + Math.min(mimeLen, maxTextBytes))); off += mimeLen;
+ const descLen = u32be(data, off); off += 4;
+ const description = safeUtf8(data.slice(off, off + Math.min(descLen, maxTextBytes))); off += descLen + 16;
+ return { mime, description, dataLength: u32be(data, off) };
+}
+
+/** Parses the ASF Content Description Object fields. */
+function parseAsfContentDescription(b, off) {
+ const titleLen = u16le(b, off), authorLen = u16le(b, off + 2);
+ const copyrightLen = u16le(b, off + 4), descLen = u16le(b, off + 6), ratingLen = u16le(b, off + 8);
+ let pos = off + 10;
+ const title = decodeUtf16LE(b, pos, titleLen); pos += titleLen;
+ const author = decodeUtf16LE(b, pos, authorLen); pos += authorLen;
+ const copyright = decodeUtf16LE(b, pos, copyrightLen); pos += copyrightLen;
+ const description = decodeUtf16LE(b, pos, descLen); pos += descLen;
+ const rating = decodeUtf16LE(b, pos, ratingLen);
+ return { title, author, copyright, description, rating };
+}
+
+/** Parses the ASF Extended Content Description Object descriptors. */
+function parseAsfExtContentDescription(b, off, end) {
+ const count = u16le(b, off);
+ let pos = off + 2;
+ const descriptors = [];
+ for (let i = 0; i < count && pos + 6 <= end && descriptors.length < 5000; i++) {
+ const nameLen = u16le(b, pos); pos += 2;
+ if (pos + nameLen > end) break;
+ const name = decodeUtf16LE(b, pos, nameLen); pos += nameLen;
+ const valueType = u16le(b, pos); pos += 2;
+ const valueLen = u16le(b, pos); pos += 2;
+ if (pos + valueLen > end) break;
+ let value;
+ if (valueType === 0) value = decodeUtf16LE(b, pos, valueLen);
+ else if (valueType === 3) value = u32le(b, pos);
+ else if (valueType === 5) value = u16le(b, pos);
+ else if (valueType === 2) value = u32le(b, pos) !== 0;
+ else value = `(${valueLen} bytes, type ${valueType})`;
+ pos += valueLen;
+ descriptors.push({ name, value_type: valueType, value });
+ }
+ return descriptors;
+}
diff --git a/src/core/lib/Base32.mjs b/src/core/lib/Base32.mjs
new file mode 100644
index 00000000..92b76eca
--- /dev/null
+++ b/src/core/lib/Base32.mjs
@@ -0,0 +1,23 @@
+// import Utils from "../Utils.mjs";
+
+/**
+ * Base32 resources.
+ *
+ * @author Peter C-S [petercs@purelymail.com]
+ * @license Apache-2.0
+ */
+
+/**
+ * Base32 alphabets.
+ */
+export const ALPHABET_OPTIONS = [
+ {
+ name: "Standard", // https://www.rfc-editor.org/rfc/rfc4648#section-6
+ value: "A-Z2-7=",
+ },
+ {
+ name: "Hex Extended", // https://www.rfc-editor.org/rfc/rfc4648#section-7
+ value: "0-9A-V=",
+ },
+];
+
diff --git a/src/core/lib/Base64.mjs b/src/core/lib/Base64.mjs
index c26630b9..aeda98cf 100644
--- a/src/core/lib/Base64.mjs
+++ b/src/core/lib/Base64.mjs
@@ -25,12 +25,12 @@ import OperationError from "../errors/OperationError.mjs";
*/
export function toBase64(data, alphabet="A-Za-z0-9+/=") {
if (!data) return "";
+ if (typeof data == "string") {
+ data = Utils.strToArrayBuffer(data);
+ }
if (data instanceof ArrayBuffer) {
data = new Uint8Array(data);
}
- if (typeof data == "string") {
- data = Utils.strToByteArray(data);
- }
alphabet = Utils.expandAlphRange(alphabet).join("");
if (alphabet.length !== 64 && alphabet.length !== 65) { // Allow for padding
diff --git a/src/core/lib/Base92.mjs b/src/core/lib/Base92.mjs
new file mode 100644
index 00000000..902c3e7d
--- /dev/null
+++ b/src/core/lib/Base92.mjs
@@ -0,0 +1,44 @@
+/**
+ * Base92 resources.
+ *
+ * @author sg5506844 [sg5506844@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Base92 alphabet char
+ *
+ * @param {number} val
+ * @returns {number}
+ */
+export function base92Chr(val) {
+ if (val < 0 || val >= 91) {
+ throw new OperationError("Invalid value");
+ }
+ if (val === 0)
+ return "!".charCodeAt(0);
+ else if (val <= 61)
+ return "#".charCodeAt(0) + val - 1;
+ else
+ return "a".charCodeAt(0) + val - 62;
+}
+
+/**
+ * Base92 alphabet ord
+ *
+ * @param {string} val
+ * @returns {number}
+ */
+export function base92Ord(val) {
+ if (val === "!")
+ return 0;
+ else if ("#" <= val && val <= "_")
+ return val.charCodeAt(0) - "#".charCodeAt(0) + 1;
+ else if ("a" <= val && val <= "}")
+ return val.charCodeAt(0) - "a".charCodeAt(0) + 62;
+ throw new OperationError(`${val} is not a base92 character`);
+}
+
diff --git a/src/core/lib/Bech32.mjs b/src/core/lib/Bech32.mjs
new file mode 100644
index 00000000..6b87a142
--- /dev/null
+++ b/src/core/lib/Bech32.mjs
@@ -0,0 +1,371 @@
+/**
+ * Pure JavaScript implementation of Bech32 and Bech32m encoding.
+ *
+ * Bech32 is defined in BIP-0173: https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki
+ * Bech32m is defined in BIP-0350: https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki
+ *
+ * @author Medjedtxm
+ * @copyright Crown Copyright 2025
+ * @license Apache-2.0
+ */
+
+import OperationError from "../errors/OperationError.mjs";
+
+/** Bech32 character set (32 characters, excludes 1, b, i, o) */
+const CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+
+/** Reverse lookup table for decoding */
+const CHARSET_REV = {};
+for (let i = 0; i < CHARSET.length; i++) {
+ CHARSET_REV[CHARSET[i]] = i;
+}
+
+/** Checksum constant for Bech32 (BIP-0173) */
+const BECH32_CONST = 1;
+
+/** Checksum constant for Bech32m (BIP-0350) */
+const BECH32M_CONST = 0x2bc830a3;
+
+/** Generator polynomial coefficients for checksum */
+const GENERATOR = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];
+
+/**
+ * Compute the polymod checksum
+ * @param {number[]} values - Array of 5-bit values
+ * @returns {number} - Checksum value
+ */
+function polymod(values) {
+ let chk = 1;
+ for (const v of values) {
+ const top = chk >> 25;
+ chk = ((chk & 0x1ffffff) << 5) ^ v;
+ for (let i = 0; i < 5; i++) {
+ if ((top >> i) & 1) {
+ chk ^= GENERATOR[i];
+ }
+ }
+ }
+ return chk;
+}
+
+/**
+ * Expand HRP for checksum computation
+ * @param {string} hrp - Human-readable part (lowercase)
+ * @returns {number[]} - Expanded values
+ */
+function hrpExpand(hrp) {
+ const result = [];
+ for (let i = 0; i < hrp.length; i++) {
+ result.push(hrp.charCodeAt(i) >> 5);
+ }
+ result.push(0);
+ for (let i = 0; i < hrp.length; i++) {
+ result.push(hrp.charCodeAt(i) & 31);
+ }
+ return result;
+}
+
+/**
+ * Verify checksum of a Bech32/Bech32m string
+ * @param {string} hrp - Human-readable part (lowercase)
+ * @param {number[]} data - Data including checksum (5-bit values)
+ * @param {string} encoding - "Bech32" or "Bech32m"
+ * @returns {boolean} - True if checksum is valid
+ */
+function verifyChecksum(hrp, data, encoding) {
+ const constant = encoding === "Bech32m" ? BECH32M_CONST : BECH32_CONST;
+ return polymod(hrpExpand(hrp).concat(data)) === constant;
+}
+
+/**
+ * Create checksum for Bech32/Bech32m encoding
+ * @param {string} hrp - Human-readable part (lowercase)
+ * @param {number[]} data - Data values (5-bit)
+ * @param {string} encoding - "Bech32" or "Bech32m"
+ * @returns {number[]} - 6 checksum values
+ */
+function createChecksum(hrp, data, encoding) {
+ const constant = encoding === "Bech32m" ? BECH32M_CONST : BECH32_CONST;
+ const values = hrpExpand(hrp).concat(data).concat([0, 0, 0, 0, 0, 0]);
+ const mod = polymod(values) ^ constant;
+ const result = [];
+ for (let i = 0; i < 6; i++) {
+ result.push((mod >> (5 * (5 - i))) & 31);
+ }
+ return result;
+}
+
+/**
+ * Convert 8-bit bytes to 5-bit words
+ * @param {number[]|Uint8Array} data - Input bytes
+ * @returns {number[]} - 5-bit words
+ */
+export function toWords(data) {
+ let value = 0;
+ let bits = 0;
+ const result = [];
+
+ for (let i = 0; i < data.length; i++) {
+ value = (value << 8) | data[i];
+ bits += 8;
+
+ while (bits >= 5) {
+ bits -= 5;
+ result.push((value >> bits) & 31);
+ }
+ }
+
+ // Pad remaining bits
+ if (bits > 0) {
+ result.push((value << (5 - bits)) & 31);
+ }
+
+ return result;
+}
+
+/**
+ * Convert 5-bit words to 8-bit bytes
+ * @param {number[]} words - 5-bit words
+ * @returns {number[]} - Output bytes
+ */
+export function fromWords(words) {
+ let value = 0;
+ let bits = 0;
+ const result = [];
+
+ for (let i = 0; i < words.length; i++) {
+ value = (value << 5) | words[i];
+ bits += 5;
+
+ while (bits >= 8) {
+ bits -= 8;
+ result.push((value >> bits) & 255);
+ }
+ }
+
+ // Check for invalid padding per BIP-0173
+ // Condition 1: Cannot have 5+ bits remaining (would indicate incomplete byte)
+ if (bits >= 5) {
+ throw new OperationError("Invalid padding: too many bits remaining");
+ }
+ // Condition 2: Remaining padding bits must all be zero
+ if (bits > 0) {
+ const paddingValue = (value << (8 - bits)) & 255;
+ if (paddingValue !== 0) {
+ throw new OperationError("Invalid padding: non-zero bits in padding");
+ }
+ }
+
+ return result;
+}
+
+/**
+ * Encode data to Bech32/Bech32m string
+ *
+ * @param {string} hrp - Human-readable part
+ * @param {number[]|Uint8Array} data - Data bytes to encode
+ * @param {string} encoding - "Bech32" or "Bech32m"
+ * @param {boolean} segwit - If true, treat first byte as witness version (for Bitcoin SegWit)
+ * @returns {string} - Encoded Bech32/Bech32m string
+ */
+export function encode(hrp, data, encoding = "Bech32", segwit = false) {
+ // Validate HRP
+ if (!hrp || hrp.length === 0) {
+ throw new OperationError("Human-Readable Part (HRP) cannot be empty.");
+ }
+
+ // Check HRP characters (ASCII 33-126)
+ for (let i = 0; i < hrp.length; i++) {
+ const c = hrp.charCodeAt(i);
+ if (c < 33 || c > 126) {
+ throw new OperationError(`HRP contains invalid character at position ${i}. Only printable ASCII characters (33-126) are allowed.`);
+ }
+ }
+
+ // Convert HRP to lowercase
+ const hrpLower = hrp.toLowerCase();
+
+ let words;
+ if (segwit && data.length >= 2) {
+ // SegWit encoding: first byte is witness version (0-16), rest is witness program
+ const witnessVersion = data[0];
+ if (witnessVersion > 16) {
+ throw new OperationError(`Invalid witness version: ${witnessVersion}. Must be 0-16.`);
+ }
+ const witnessProgram = Array.prototype.slice.call(data, 1);
+
+ // Validate witness program length per BIP-0141
+ if (witnessProgram.length < 2 || witnessProgram.length > 40) {
+ throw new OperationError(`Invalid witness program length: ${witnessProgram.length}. Must be 2-40 bytes.`);
+ }
+ if (witnessVersion === 0 && witnessProgram.length !== 20 && witnessProgram.length !== 32) {
+ throw new OperationError(`Invalid witness program length for v0: ${witnessProgram.length}. Must be 20 or 32 bytes.`);
+ }
+
+ // Witness version is kept as single 5-bit value, program is converted
+ words = [witnessVersion].concat(toWords(witnessProgram));
+ } else {
+ // Generic encoding: convert all bytes to 5-bit words
+ words = toWords(data);
+ }
+
+ // Create checksum
+ const checksum = createChecksum(hrpLower, words, encoding);
+
+ // Build result string
+ let result = hrpLower + "1";
+ for (const w of words.concat(checksum)) {
+ result += CHARSET[w];
+ }
+
+ // Check maximum length (90 characters)
+ if (result.length > 90) {
+ throw new OperationError(`Encoded string exceeds maximum length of 90 characters (got ${result.length}). Consider using smaller input data.`);
+ }
+
+ return result;
+}
+
+/**
+ * Decode a Bech32/Bech32m string
+ *
+ * @param {string} str - Bech32/Bech32m encoded string
+ * @param {string} encoding - "Bech32", "Bech32m", or "Auto-detect"
+ * @returns {{hrp: string, data: number[]}} - Decoded HRP and data bytes
+ */
+export function decode(str, encoding = "Auto-detect") {
+ // Check for empty input
+ if (!str || str.length === 0) {
+ throw new OperationError("Input cannot be empty.");
+ }
+
+ // Check maximum length
+ if (str.length > 90) {
+ throw new OperationError(`Invalid Bech32 string: exceeds maximum length of 90 characters (got ${str.length}).`);
+ }
+
+ // Check for mixed case
+ const hasUpper = /[A-Z]/.test(str);
+ const hasLower = /[a-z]/.test(str);
+ if (hasUpper && hasLower) {
+ throw new OperationError("Invalid Bech32 string: mixed case is not allowed. Use all uppercase or all lowercase.");
+ }
+
+ // Convert to lowercase for processing
+ str = str.toLowerCase();
+
+ // Find separator (last occurrence of '1')
+ const sepIndex = str.lastIndexOf("1");
+ if (sepIndex === -1) {
+ throw new OperationError("Invalid Bech32 string: no separator '1' found.");
+ }
+
+ if (sepIndex === 0) {
+ throw new OperationError("Invalid Bech32 string: Human-Readable Part (HRP) cannot be empty.");
+ }
+
+ if (sepIndex + 7 > str.length) {
+ throw new OperationError("Invalid Bech32 string: data part is too short (minimum 6 characters for checksum).");
+ }
+
+ // Extract HRP and data part
+ const hrp = str.substring(0, sepIndex);
+ const dataPart = str.substring(sepIndex + 1);
+
+ // Validate HRP characters
+ for (let i = 0; i < hrp.length; i++) {
+ const c = hrp.charCodeAt(i);
+ if (c < 33 || c > 126) {
+ throw new OperationError(`HRP contains invalid character at position ${i}.`);
+ }
+ }
+
+ // Decode data characters to 5-bit values
+ const data = [];
+ for (let i = 0; i < dataPart.length; i++) {
+ const c = dataPart[i];
+ if (CHARSET_REV[c] === undefined) {
+ throw new OperationError(`Invalid character '${c}' at position ${sepIndex + 1 + i}.`);
+ }
+ data.push(CHARSET_REV[c]);
+ }
+
+ // Verify checksum
+ let usedEncoding;
+ if (encoding === "Bech32") {
+ if (!verifyChecksum(hrp, data, "Bech32")) {
+ throw new OperationError("Invalid Bech32 checksum.");
+ }
+ usedEncoding = "Bech32";
+ } else if (encoding === "Bech32m") {
+ if (!verifyChecksum(hrp, data, "Bech32m")) {
+ throw new OperationError("Invalid Bech32m checksum.");
+ }
+ usedEncoding = "Bech32m";
+ } else {
+ // Auto-detect: try Bech32 first, then Bech32m
+ if (verifyChecksum(hrp, data, "Bech32")) {
+ usedEncoding = "Bech32";
+ } else if (verifyChecksum(hrp, data, "Bech32m")) {
+ usedEncoding = "Bech32m";
+ } else {
+ throw new OperationError("Invalid Bech32/Bech32m string: checksum verification failed.");
+ }
+ }
+
+ // Remove checksum (last 6 values)
+ const words = data.slice(0, data.length - 6);
+
+ // Check if this is likely a SegWit address (Bitcoin, Litecoin, etc.)
+ // For SegWit, the first 5-bit word is the witness version (0-16)
+ // and should be extracted separately, not bit-converted with the rest
+ const segwitHrps = ["bc", "tb", "ltc", "tltc", "bcrt"];
+ const couldBeSegWit = segwitHrps.includes(hrp) && words.length > 0 && words[0] <= 16;
+
+ let bytes;
+ let witnessVersion = null;
+
+ if (couldBeSegWit) {
+ // Try SegWit decode first
+ try {
+ witnessVersion = words[0];
+ const programWords = words.slice(1);
+ const programBytes = fromWords(programWords);
+
+ // Validate SegWit witness program length (20 or 32 bytes for v0, 2-40 for others)
+ const validV0 = witnessVersion === 0 && (programBytes.length === 20 || programBytes.length === 32);
+ const validOther = witnessVersion !== 0 && programBytes.length >= 2 && programBytes.length <= 40;
+
+ if (validV0 || validOther) {
+ // Valid SegWit address
+ bytes = [witnessVersion, ...programBytes];
+ } else {
+ // Not valid SegWit, fall back to generic decode
+ witnessVersion = null;
+ bytes = fromWords(words);
+ }
+ } catch (e) {
+ // SegWit decode failed, try generic decode
+ witnessVersion = null;
+ try {
+ bytes = fromWords(words);
+ } catch (e2) {
+ throw new OperationError(`Failed to decode data: ${e2.message}`);
+ }
+ }
+ } else {
+ // Generic Bech32: convert all words
+ try {
+ bytes = fromWords(words);
+ } catch (e) {
+ throw new OperationError(`Failed to decode data: ${e.message}`);
+ }
+ }
+
+ return {
+ hrp: hrp,
+ data: bytes,
+ encoding: usedEncoding,
+ witnessVersion: witnessVersion
+ };
+}
diff --git a/src/core/lib/BigIntUtils.mjs b/src/core/lib/BigIntUtils.mjs
new file mode 100644
index 00000000..5ddd8786
--- /dev/null
+++ b/src/core/lib/BigIntUtils.mjs
@@ -0,0 +1,73 @@
+/**
+ * @author p-leriche [philip.leriche@cantab.net]
+ * @copyright Crown Copyright 2025
+ * @license Apache-2.0
+ */
+
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Number theory utilities used by cryptographic operations.
+ *
+ * Currently provides:
+ * - parseBigInt
+ * - Extended Euclidean Algorithm
+ * - Modular Exponentiation
+ *
+ * Additional algorithms may be added as required.
+ */
+
+/**
+ * parseBigInt helper operation
+ */
+export function parseBigInt(value, param) {
+ const v = (value ?? "").trim();
+ if (/^0x[0-9a-f]+$/i.test(v)) return BigInt(v);
+ if (/^[+-]?[0-9]+$/.test(v)) return BigInt(v);
+ throw new OperationError(param + " must be decimal or hex (0x...)");
+}
+
+/**
+ * Extended Euclidean Algorithm
+ *
+ * Returns [g, x, y] such that:
+ * a*x + b*y = g = gcd(a, b)
+ *
+ * (Uses an iterative algorithm to avoid possible stack overflow)
+ */
+export function egcd(a, b) {
+ let oldR = a, r = b;
+ let oldS = 1n, s = 0n;
+ let oldT = 0n, t = 1n;
+
+ while (r !== 0n) {
+ const quotient = oldR / r;
+
+ [oldR, r] = [r, oldR - quotient * r];
+ [oldS, s] = [s, oldS - quotient * s];
+ [oldT, t] = [t, oldT - quotient * t];
+ }
+
+ // oldR is the gcd
+ // oldS and oldT are the Bézout coefficients
+ return [oldR, oldS, oldT];
+}
+
+/**
+ * Modular exponentiation
+ */
+export function modPow(base, exponent, modulus) {
+ let result = 1n;
+ base %= modulus;
+
+ while (exponent > 0n) {
+ if (exponent & 1n) {
+ result = (result * base) % modulus;
+ }
+ base = (base * base) % modulus;
+ exponent >>= 1n;
+ }
+
+ return result;
+}
+
diff --git a/src/core/lib/ChrEnc.mjs b/src/core/lib/ChrEnc.mjs
index c5cb5605..55fe3761 100644
--- a/src/core/lib/ChrEnc.mjs
+++ b/src/core/lib/ChrEnc.mjs
@@ -6,10 +6,12 @@
* @license Apache-2.0
*/
+import cptable from "codepage";
+
/**
* Character encoding format mappings.
*/
-export const IO_FORMAT = {
+export const CHR_ENC_CODE_PAGES = {
"UTF-8 (65001)": 65001,
"UTF-7 (65000)": 65000,
"UTF-16LE (1200)": 1200,
@@ -164,6 +166,57 @@ export const IO_FORMAT = {
"Simplified Chinese GB18030 (54936)": 54936,
};
+
+export const CHR_ENC_SIMPLE_LOOKUP = {};
+export const CHR_ENC_SIMPLE_REVERSE_LOOKUP = {};
+
+for (const name in CHR_ENC_CODE_PAGES) {
+ const simpleName = name.match(/(^.+)\([\d/]+\)$/)[1];
+
+ CHR_ENC_SIMPLE_LOOKUP[simpleName] = CHR_ENC_CODE_PAGES[name];
+ CHR_ENC_SIMPLE_REVERSE_LOOKUP[CHR_ENC_CODE_PAGES[name]] = simpleName;
+}
+
+
+/**
+ * Returns the width of the character set for the given codepage.
+ * For example, UTF-8 is a Single Byte Character Set, whereas
+ * UTF-16 is a Double Byte Character Set.
+ *
+ * @param {number} page - The codepage number
+ * @returns {number}
+ */
+export function chrEncWidth(page) {
+ if (typeof page !== "number") return 0;
+
+ // Raw Bytes have a width of 1
+ if (page === 0) return 1;
+
+ const pageStr = page.toString();
+ // Confirm this page is legitimate
+ if (!Object.prototype.hasOwnProperty.call(CHR_ENC_SIMPLE_REVERSE_LOOKUP, pageStr))
+ return 0;
+
+ // Statically defined code pages
+ if (Object.prototype.hasOwnProperty.call(cptable, pageStr))
+ return cptable[pageStr].dec.length > 256 ? 2 : 1;
+
+ // Cached code pages
+ if (cptable.utils.cache.sbcs.includes(pageStr))
+ return 1;
+ if (cptable.utils.cache.dbcs.includes(pageStr))
+ return 2;
+
+ // Dynamically generated code pages
+ if (Object.prototype.hasOwnProperty.call(cptable.utils.magic, pageStr)) {
+ // Generate a single character and measure it
+ const a = cptable.utils.encode(page, "a");
+ return a.length;
+ }
+
+ return 0;
+}
+
/**
* Unicode Normalisation Forms
*
@@ -171,8 +224,85 @@ export const IO_FORMAT = {
* @copyright Crown Copyright 2019
* @license Apache-2.0
*/
+export const UNICODE_NORMALISATION_FORMS = ["NFD", "NFC", "NFKD", "NFKC"];
+
/**
- * Character encoding format mappings.
+ * Detects whether the input buffer is valid UTF8.
+ *
+ * @param {ArrayBuffer} data
+ * @returns {number} - 0 = not UTF8, 1 = ASCII, 2 = UTF8
*/
-export const UNICODE_NORMALISATION_FORMS = ["NFD", "NFC", "NFKD", "NFKC"];
+export function isUTF8(data) {
+ const bytes = new Uint8Array(data);
+ let i = 0;
+ let onlyASCII = true;
+ while (i < bytes.length) {
+ if (( // ASCII
+ bytes[i] === 0x09 ||
+ bytes[i] === 0x0A ||
+ bytes[i] === 0x0D ||
+ (0x20 <= bytes[i] && bytes[i] <= 0x7E)
+ )) {
+ i += 1;
+ continue;
+ }
+
+ onlyASCII = false;
+
+ if (( // non-overlong 2-byte
+ (0xC2 <= bytes[i] && bytes[i] <= 0xDF) &&
+ (0x80 <= bytes[i+1] && bytes[i+1] <= 0xBF)
+ )) {
+ i += 2;
+ continue;
+ }
+
+ if (( // excluding overlongs
+ bytes[i] === 0xE0 &&
+ (0xA0 <= bytes[i + 1] && bytes[i + 1] <= 0xBF) &&
+ (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF)
+ ) ||
+ ( // straight 3-byte
+ ((0xE1 <= bytes[i] && bytes[i] <= 0xEC) ||
+ bytes[i] === 0xEE ||
+ bytes[i] === 0xEF) &&
+ (0x80 <= bytes[i + 1] && bytes[i+1] <= 0xBF) &&
+ (0x80 <= bytes[i+2] && bytes[i+2] <= 0xBF)
+ ) ||
+ ( // excluding surrogates
+ bytes[i] === 0xED &&
+ (0x80 <= bytes[i+1] && bytes[i+1] <= 0x9F) &&
+ (0x80 <= bytes[i+2] && bytes[i+2] <= 0xBF)
+ )) {
+ i += 3;
+ continue;
+ }
+
+ if (( // planes 1-3
+ bytes[i] === 0xF0 &&
+ (0x90 <= bytes[i + 1] && bytes[i + 1] <= 0xBF) &&
+ (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF) &&
+ (0x80 <= bytes[i + 3] && bytes[i + 3] <= 0xBF)
+ ) ||
+ ( // planes 4-15
+ (0xF1 <= bytes[i] && bytes[i] <= 0xF3) &&
+ (0x80 <= bytes[i + 1] && bytes[i + 1] <= 0xBF) &&
+ (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF) &&
+ (0x80 <= bytes[i + 3] && bytes[i + 3] <= 0xBF)
+ ) ||
+ ( // plane 16
+ bytes[i] === 0xF4 &&
+ (0x80 <= bytes[i + 1] && bytes[i + 1] <= 0x8F) &&
+ (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF) &&
+ (0x80 <= bytes[i + 3] && bytes[i + 3] <= 0xBF)
+ )) {
+ i += 4;
+ continue;
+ }
+
+ return 0;
+ }
+
+ return onlyASCII ? 1 : 2;
+}
diff --git a/src/core/lib/CipherSaber2.mjs b/src/core/lib/CipherSaber2.mjs
index bf3954e9..8189d961 100644
--- a/src/core/lib/CipherSaber2.mjs
+++ b/src/core/lib/CipherSaber2.mjs
@@ -4,7 +4,7 @@
* @license Apache-2.0
*/
export function encode(tempIVP, key, rounds, input) {
- const ivp = new Uint8Array(key.concat(tempIVP));
+ const ivp = new Uint8Array([...key, ...tempIVP]);
const state = new Array(256).fill(0);
let j = 0, i = 0;
const result = [];
diff --git a/src/core/lib/Ciphers.mjs b/src/core/lib/Ciphers.mjs
index a4d174b5..6266a8e1 100644
--- a/src/core/lib/Ciphers.mjs
+++ b/src/core/lib/Ciphers.mjs
@@ -3,6 +3,7 @@
*
* @author Matt C [matt@artemisbot.uk]
* @author n1474335 [n1474335@gmail.com]
+ * @author Evie H [evie@evie.sh]
*
* @copyright Crown Copyright 2018
* @license Apache-2.0
@@ -10,6 +11,7 @@
*/
import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
import CryptoJS from "crypto-js";
/**
@@ -30,6 +32,10 @@ export function affineEncode(input, args) {
throw new OperationError("The values of a and b can only be integers.");
}
+ if (Utils.gcd(a, 26) !== 1) {
+ throw new OperationError("The value of `a` must be coprime to 26.");
+ }
+
for (let i = 0; i < input.length; i++) {
if (alphabet.indexOf(input[i]) >= 0) {
// Uses the affine function ax+b % m = y (where m is length of the alphabet)
diff --git a/src/core/lib/Extract.mjs b/src/core/lib/Extract.mjs
index 18fec28c..8828671e 100644
--- a/src/core/lib/Extract.mjs
+++ b/src/core/lib/Extract.mjs
@@ -45,6 +45,11 @@ export function search(input, searchRegex, removeRegex=null, sortBy=null, unique
return results;
}
+/**
+ * Email regular expression
+ */
+export const EMAIL_REGEX = /(?:[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9](?:[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9-]*[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9])?\.)+[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9](?:[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9-]*[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\])/ig;
+
/**
* URL regular expression
@@ -62,3 +67,9 @@ export const URL_REGEX = new RegExp(protocol + hostname + "(?:" + port + ")?(?:"
* Domain name regular expression
*/
export const DOMAIN_REGEX = /\b((?=[a-z0-9-]{1,63}\.)(xn--)?[a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,63}\b/ig;
+
+
+/**
+ * DMARC Domain name regular expression
+ */
+export const DMARC_DOMAIN_REGEX = /\b((?=[a-z0-9_-]{1,63}\.)(xn--)?[a-z0-9_]+(-[a-z0-9_]+)*\.)+[a-z]{2,63}\b/ig;
diff --git a/src/core/lib/FileSignatures.mjs b/src/core/lib/FileSignatures.mjs
index 4cba4bc7..22132823 100644
--- a/src/core/lib/FileSignatures.mjs
+++ b/src/core/lib/FileSignatures.mjs
@@ -72,6 +72,27 @@ export const FILE_SIGNATURES = {
},
extractor: extractWEBP
},
+ {
+ name: "High Efficiency Image File Format",
+ extension: "heic,heif",
+ mime: "image/heif",
+ description: "",
+ signature: {
+ 0: 0x00,
+ 1: 0x00,
+ 2: 0x00,
+ 3: [0x24, 0x18],
+ 4: 0x66, // ftypheic
+ 5: 0x74,
+ 6: 0x79,
+ 7: 0x70,
+ 8: 0x68,
+ 9: 0x65,
+ 10: 0x69,
+ 11: 0x63
+ },
+ extractor: null
+ },
{
name: "Camera Image File Format",
extension: "crw",
@@ -2727,7 +2748,7 @@ export function extractGIF(bytes, offset) {
stream.moveForwardsBy(11);
// Loop until next Graphic Control Extension.
- while (stream.getBytes(2) !== [0x21, 0xf9]) {
+ while (!Array.from(stream.getBytes(2)).equals([0x21, 0xf9])) {
stream.moveBackwardsBy(2);
stream.moveForwardsBy(stream.readInt(1));
if (!stream.readInt(1))
diff --git a/src/core/lib/Hex.mjs b/src/core/lib/Hex.mjs
index b7e8e908..6f998e2b 100644
--- a/src/core/lib/Hex.mjs
+++ b/src/core/lib/Hex.mjs
@@ -33,7 +33,7 @@ export function toHex(data, delim=" ", padding=2, extraDelim="", lineSize=0) {
if (data instanceof ArrayBuffer) data = new Uint8Array(data);
let output = "";
- const prepend = (delim === "0x" || delim === "\\x");
+ const prepend = (delim === "0x" || delim === "\\x" || delim === "%");
for (let i = 0; i < data.length; i++) {
const hex = data[i].toString(16).padStart(padding, "0");
@@ -105,13 +105,17 @@ export function fromHex(data, delim="Auto", byteLen=2) {
throw new OperationError("Byte length must be a positive integer");
if (delim !== "None") {
- const delimRegex = delim === "Auto" ? /[^a-f\d]|(0x)/gi : Utils.regexRep(delim);
- data = data.replace(delimRegex, "");
+ const delimRegex = delim === "Auto" ? /[^a-f\d]|0x/gi : Utils.regexRep(delim);
+ data = data.split(delimRegex);
+ } else {
+ data = [data];
}
const output = [];
- for (let i = 0; i < data.length; i += byteLen) {
- output.push(parseInt(data.substr(i, byteLen), 16));
+ for (let i = 0; i < data.length; i++) {
+ for (let j = 0; j < data[i].length; j += byteLen) {
+ output.push(parseInt(data[i].substr(j, byteLen), 16));
+ }
}
return output;
}
diff --git a/src/core/lib/ImageManipulation.mjs b/src/core/lib/ImageManipulation.mjs
deleted file mode 100644
index 63a80fe4..00000000
--- a/src/core/lib/ImageManipulation.mjs
+++ /dev/null
@@ -1,251 +0,0 @@
-/**
- * Image manipulation resources
- *
- * @author j433866 [j433866@gmail.com]
- * @copyright Crown Copyright 2019
- * @license Apache-2.0
- */
-
-import OperationError from "../errors/OperationError.mjs";
-
-/**
- * Gaussian blurs an image.
- *
- * @param {jimp} input
- * @param {number} radius
- * @param {boolean} fast
- * @returns {jimp}
- */
-export function gaussianBlur (input, radius) {
- try {
- // From http://blog.ivank.net/fastest-gaussian-blur.html
- const boxes = boxesForGauss(radius, 3);
- for (let i = 0; i < 3; i++) {
- input = boxBlur(input, (boxes[i] - 1) / 2);
- }
- } catch (err) {
- throw new OperationError(`Error blurring image. (${err})`);
- }
-
- return input;
-}
-
-/**
- *
- * @param {number} radius
- * @param {number} numBoxes
- * @returns {Array}
- */
-function boxesForGauss(radius, numBoxes) {
- const idealWidth = Math.sqrt((12 * radius * radius / numBoxes) + 1);
-
- let wl = Math.floor(idealWidth);
-
- if (wl % 2 === 0) {
- wl--;
- }
-
- const wu = wl + 2;
-
- const mIdeal = (12 * radius * radius - numBoxes * wl * wl - 4 * numBoxes * wl - 3 * numBoxes) / (-4 * wl - 4);
- const m = Math.round(mIdeal);
-
- const sizes = [];
- for (let i = 0; i < numBoxes; i++) {
- sizes.push(i < m ? wl : wu);
- }
- return sizes;
-}
-
-/**
- * Applies a box blur effect to the image
- *
- * @param {jimp} source
- * @param {number} radius
- * @returns {jimp}
- */
-function boxBlur (source, radius) {
- const width = source.bitmap.width;
- const height = source.bitmap.height;
- let output = source.clone();
- output = boxBlurH(source, output, width, height, radius);
- source = boxBlurV(output, source, width, height, radius);
-
- return source;
-}
-
-/**
- * Applies the horizontal blur
- *
- * @param {jimp} source
- * @param {jimp} output
- * @param {number} width
- * @param {number} height
- * @param {number} radius
- * @returns {jimp}
- */
-function boxBlurH (source, output, width, height, radius) {
- const iarr = 1 / (radius + radius + 1);
- for (let i = 0; i < height; i++) {
- let ti = 0,
- li = ti,
- ri = ti + radius;
- const idx = source.getPixelIndex(ti, i);
- const firstValRed = source.bitmap.data[idx],
- firstValGreen = source.bitmap.data[idx + 1],
- firstValBlue = source.bitmap.data[idx + 2],
- firstValAlpha = source.bitmap.data[idx + 3];
-
- const lastIdx = source.getPixelIndex(width - 1, i),
- lastValRed = source.bitmap.data[lastIdx],
- lastValGreen = source.bitmap.data[lastIdx + 1],
- lastValBlue = source.bitmap.data[lastIdx + 2],
- lastValAlpha = source.bitmap.data[lastIdx + 3];
-
- let red = (radius + 1) * firstValRed;
- let green = (radius + 1) * firstValGreen;
- let blue = (radius + 1) * firstValBlue;
- let alpha = (radius + 1) * firstValAlpha;
-
- for (let j = 0; j < radius; j++) {
- const jIdx = source.getPixelIndex(ti + j, i);
- red += source.bitmap.data[jIdx];
- green += source.bitmap.data[jIdx + 1];
- blue += source.bitmap.data[jIdx + 2];
- alpha += source.bitmap.data[jIdx + 3];
- }
-
- for (let j = 0; j <= radius; j++) {
- const jIdx = source.getPixelIndex(ri++, i);
- red += source.bitmap.data[jIdx] - firstValRed;
- green += source.bitmap.data[jIdx + 1] - firstValGreen;
- blue += source.bitmap.data[jIdx + 2] - firstValBlue;
- alpha += source.bitmap.data[jIdx + 3] - firstValAlpha;
-
- const tiIdx = source.getPixelIndex(ti++, i);
- output.bitmap.data[tiIdx] = Math.round(red * iarr);
- output.bitmap.data[tiIdx + 1] = Math.round(green * iarr);
- output.bitmap.data[tiIdx + 2] = Math.round(blue * iarr);
- output.bitmap.data[tiIdx + 3] = Math.round(alpha * iarr);
- }
-
- for (let j = radius + 1; j < width - radius; j++) {
- const riIdx = source.getPixelIndex(ri++, i);
- const liIdx = source.getPixelIndex(li++, i);
- red += source.bitmap.data[riIdx] - source.bitmap.data[liIdx];
- green += source.bitmap.data[riIdx + 1] - source.bitmap.data[liIdx + 1];
- blue += source.bitmap.data[riIdx + 2] - source.bitmap.data[liIdx + 2];
- alpha += source.bitmap.data[riIdx + 3] - source.bitmap.data[liIdx + 3];
-
- const tiIdx = source.getPixelIndex(ti++, i);
- output.bitmap.data[tiIdx] = Math.round(red * iarr);
- output.bitmap.data[tiIdx + 1] = Math.round(green * iarr);
- output.bitmap.data[tiIdx + 2] = Math.round(blue * iarr);
- output.bitmap.data[tiIdx + 3] = Math.round(alpha * iarr);
- }
-
- for (let j = width - radius; j < width; j++) {
- const liIdx = source.getPixelIndex(li++, i);
- red += lastValRed - source.bitmap.data[liIdx];
- green += lastValGreen - source.bitmap.data[liIdx + 1];
- blue += lastValBlue - source.bitmap.data[liIdx + 2];
- alpha += lastValAlpha - source.bitmap.data[liIdx + 3];
-
- const tiIdx = source.getPixelIndex(ti++, i);
- output.bitmap.data[tiIdx] = Math.round(red * iarr);
- output.bitmap.data[tiIdx + 1] = Math.round(green * iarr);
- output.bitmap.data[tiIdx + 2] = Math.round(blue * iarr);
- output.bitmap.data[tiIdx + 3] = Math.round(alpha * iarr);
- }
- }
- return output;
-}
-
-/**
- * Applies the vertical blur
- *
- * @param {jimp} source
- * @param {jimp} output
- * @param {number} width
- * @param {number} height
- * @param {number} radius
- * @returns {jimp}
- */
-function boxBlurV (source, output, width, height, radius) {
- const iarr = 1 / (radius + radius + 1);
- for (let i = 0; i < width; i++) {
- let ti = 0,
- li = ti,
- ri = ti + radius;
-
- const idx = source.getPixelIndex(i, ti);
-
- const firstValRed = source.bitmap.data[idx],
- firstValGreen = source.bitmap.data[idx + 1],
- firstValBlue = source.bitmap.data[idx + 2],
- firstValAlpha = source.bitmap.data[idx + 3];
-
- const lastIdx = source.getPixelIndex(i, height - 1),
- lastValRed = source.bitmap.data[lastIdx],
- lastValGreen = source.bitmap.data[lastIdx + 1],
- lastValBlue = source.bitmap.data[lastIdx + 2],
- lastValAlpha = source.bitmap.data[lastIdx + 3];
-
- let red = (radius + 1) * firstValRed;
- let green = (radius + 1) * firstValGreen;
- let blue = (radius + 1) * firstValBlue;
- let alpha = (radius + 1) * firstValAlpha;
-
- for (let j = 0; j < radius; j++) {
- const jIdx = source.getPixelIndex(i, ti + j);
- red += source.bitmap.data[jIdx];
- green += source.bitmap.data[jIdx + 1];
- blue += source.bitmap.data[jIdx + 2];
- alpha += source.bitmap.data[jIdx + 3];
- }
-
- for (let j = 0; j <= radius; j++) {
- const riIdx = source.getPixelIndex(i, ri++);
- red += source.bitmap.data[riIdx] - firstValRed;
- green += source.bitmap.data[riIdx + 1] - firstValGreen;
- blue += source.bitmap.data[riIdx + 2] - firstValBlue;
- alpha += source.bitmap.data[riIdx + 3] - firstValAlpha;
-
- const tiIdx = source.getPixelIndex(i, ti++);
- output.bitmap.data[tiIdx] = Math.round(red * iarr);
- output.bitmap.data[tiIdx + 1] = Math.round(green * iarr);
- output.bitmap.data[tiIdx + 2] = Math.round(blue * iarr);
- output.bitmap.data[tiIdx + 3] = Math.round(alpha * iarr);
- }
-
- for (let j = radius + 1; j < height - radius; j++) {
- const riIdx = source.getPixelIndex(i, ri++);
- const liIdx = source.getPixelIndex(i, li++);
- red += source.bitmap.data[riIdx] - source.bitmap.data[liIdx];
- green += source.bitmap.data[riIdx + 1] - source.bitmap.data[liIdx + 1];
- blue += source.bitmap.data[riIdx + 2] - source.bitmap.data[liIdx + 2];
- alpha += source.bitmap.data[riIdx + 3] - source.bitmap.data[liIdx + 3];
-
- const tiIdx = source.getPixelIndex(i, ti++);
- output.bitmap.data[tiIdx] = Math.round(red * iarr);
- output.bitmap.data[tiIdx + 1] = Math.round(green * iarr);
- output.bitmap.data[tiIdx + 2] = Math.round(blue * iarr);
- output.bitmap.data[tiIdx + 3] = Math.round(alpha * iarr);
- }
-
- for (let j = height - radius; j < height; j++) {
- const liIdx = source.getPixelIndex(i, li++);
- red += lastValRed - source.bitmap.data[liIdx];
- green += lastValGreen - source.bitmap.data[liIdx + 1];
- blue += lastValBlue - source.bitmap.data[liIdx + 2];
- alpha += lastValAlpha - source.bitmap.data[liIdx + 3];
-
- const tiIdx = source.getPixelIndex(i, ti++);
- output.bitmap.data[tiIdx] = Math.round(red * iarr);
- output.bitmap.data[tiIdx + 1] = Math.round(green * iarr);
- output.bitmap.data[tiIdx + 2] = Math.round(blue * iarr);
- output.bitmap.data[tiIdx + 3] = Math.round(alpha * iarr);
- }
- }
- return output;
-}
diff --git a/src/core/lib/JA4.mjs b/src/core/lib/JA4.mjs
new file mode 100644
index 00000000..58422bca
--- /dev/null
+++ b/src/core/lib/JA4.mjs
@@ -0,0 +1,290 @@
+/**
+ * JA4 resources.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ *
+ * JA4 Copyright 2023 FoxIO, LLC.
+ * @license BSD-3-Clause
+ */
+
+import OperationError from "../errors/OperationError.mjs";
+import { parseTLSRecord, parseHighestSupportedVersion, parseFirstALPNValue } from "./TLS.mjs";
+import { toHexFast } from "./Hex.mjs";
+import { runHash } from "./Hash.mjs";
+import Utils from "../Utils.mjs";
+
+
+/**
+ * Calculate the JA4 from a given TLS Client Hello Stream
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function toJA4(bytes) {
+ let tlsr = {};
+ try {
+ tlsr = parseTLSRecord(bytes);
+ if (tlsr.handshake.value.handshakeType.value !== 0x01) {
+ throw new Error();
+ }
+ } catch (err) {
+ throw new OperationError("Data is not a valid TLS Client Hello. QUIC is not yet supported.\n" + err);
+ }
+
+ /* QUIC
+ “q” or “t”, which denotes whether the hello packet is for QUIC or TCP.
+ TODO: Implement QUIC
+ */
+ const ptype = "t";
+
+ /* TLS Version
+ TLS version is shown in 3 different places. If extension 0x002b exists (supported_versions), then the version
+ is the highest value in the extension. Remember to ignore GREASE values. If the extension doesn’t exist, then
+ the TLS version is the value of the Protocol Version. Handshake version (located at the top of the packet)
+ should be ignored.
+ */
+ let version = tlsr.handshake.value.helloVersion.value;
+ for (const ext of tlsr.handshake.value.extensions.value) {
+ if (ext.type.value === "supported_versions") {
+ version = parseHighestSupportedVersion(ext.value.data);
+ break;
+ }
+ }
+ version = tlsVersionMapper(version);
+
+ /* SNI
+ If the SNI extension (0x0000) exists, then the destination of the connection is a domain, or “d” in the fingerprint.
+ If the SNI does not exist, then the destination is an IP address, or “i”.
+ */
+ let sni = "i";
+ for (const ext of tlsr.handshake.value.extensions.value) {
+ if (ext.type.value === "server_name") {
+ sni = "d";
+ break;
+ }
+ }
+
+ /* Number of Ciphers
+ 2 character number of cipher suites, so if there’s 6 cipher suites in the hello packet, then the value should be “06”.
+ If there’s > 99, which there should never be, then output “99”. Remember, ignore GREASE values. They don’t count.
+ */
+ let cipherLen = 0;
+ for (const cs of tlsr.handshake.value.cipherSuites.value) {
+ if (cs.value !== "GREASE") cipherLen++;
+ }
+ cipherLen = cipherLen > 99 ? "99" : cipherLen.toString().padStart(2, "0");
+
+ /* Number of Extensions
+ Same as counting ciphers. Ignore GREASE. Include SNI and ALPN.
+ */
+ let extLen = 0;
+ for (const ext of tlsr.handshake.value.extensions.value) {
+ if (ext.type.value !== "GREASE") extLen++;
+ }
+ extLen = extLen > 99 ? "99" : extLen.toString().padStart(2, "0");
+
+ /* ALPN Extension Value
+ The first and last characters of the ALPN (Application-Layer Protocol Negotiation) first value.
+ If there are no ALPN values or no ALPN extension then we print “00” as the value in the fingerprint.
+ */
+ let alpn = "00";
+ for (const ext of tlsr.handshake.value.extensions.value) {
+ if (ext.type.value === "application_layer_protocol_negotiation") {
+ alpn = alpnFingerprint(parseFirstALPNValue(ext.value.data));
+ break;
+ }
+ }
+
+ /* Cipher hash
+ A 12 character truncated sha256 hash of the list of ciphers sorted in hex order, first 12 characters.
+ The list is created using the 4 character hex values of the ciphers, lower case, comma delimited, ignoring GREASE.
+ */
+ const originalCiphersList = [];
+ for (const cs of tlsr.handshake.value.cipherSuites.value) {
+ if (cs.value !== "GREASE") {
+ originalCiphersList.push(toHexFast(cs.data));
+ }
+ }
+ const sortedCiphersList = [...originalCiphersList].sort();
+ const sortedCiphersRaw = sortedCiphersList.join(",");
+ const originalCiphersRaw = originalCiphersList.join(",");
+ const sortedCiphers = runHash(
+ "sha256",
+ Utils.strToArrayBuffer(sortedCiphersRaw)
+ ).substring(0, 12);
+ const originalCiphers = runHash(
+ "sha256",
+ Utils.strToArrayBuffer(originalCiphersRaw)
+ ).substring(0, 12);
+
+ /* Extension hash
+ A 12 character truncated sha256 hash of the list of extensions, sorted by hex value, followed by the list of signature
+ algorithms, in the order that they appear (not sorted).
+ The extension list is created using the 4 character hex values of the extensions, lower case, comma delimited, sorted
+ (not in the order they appear). Ignore the SNI extension (0000) and the ALPN extension (0010) as we’ve already captured
+ them in the a section of the fingerprint. These values are omitted so that the same application would have the same b
+ section of the fingerprint regardless of if it were going to a domain, IP, or changing ALPNs.
+ */
+ const originalExtensionsList = [];
+ let signatureAlgorithms = "";
+ for (const ext of tlsr.handshake.value.extensions.value) {
+ if (ext.type.value !== "GREASE") {
+ originalExtensionsList.push(toHexFast(ext.type.data));
+ }
+ if (ext.type.value === "signature_algorithms") {
+ signatureAlgorithms = toHexFast(ext.value.data.slice(2));
+ signatureAlgorithms = signatureAlgorithms.replace(/(.{4})/g, "$1,");
+ signatureAlgorithms = signatureAlgorithms.substring(0, signatureAlgorithms.length - 1);
+ }
+ }
+ const sortedExtensionsList = [...originalExtensionsList].filter(e => e !== "0000" && e !== "0010").sort();
+ const sortedExtensionsRaw = sortedExtensionsList.join(",") + "_" + signatureAlgorithms;
+ const originalExtensionsRaw = originalExtensionsList.join(",") + "_" + signatureAlgorithms;
+ const sortedExtensions = runHash(
+ "sha256",
+ Utils.strToArrayBuffer(sortedExtensionsRaw)
+ ).substring(0, 12);
+ const originalExtensions = runHash(
+ "sha256",
+ Utils.strToArrayBuffer(originalExtensionsRaw)
+ ).substring(0, 12);
+
+ return {
+ "JA4": `${ptype}${version}${sni}${cipherLen}${extLen}${alpn}_${sortedCiphers}_${sortedExtensions}`,
+ "JA4_o": `${ptype}${version}${sni}${cipherLen}${extLen}${alpn}_${originalCiphers}_${originalExtensions}`,
+ "JA4_r": `${ptype}${version}${sni}${cipherLen}${extLen}${alpn}_${sortedCiphersRaw}_${sortedExtensionsRaw}`,
+ "JA4_ro": `${ptype}${version}${sni}${cipherLen}${extLen}${alpn}_${originalCiphersRaw}_${originalExtensionsRaw}`,
+ };
+}
+
+
+/**
+ * Calculate the JA4Server from a given TLS Server Hello Stream
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function toJA4S(bytes) {
+ let tlsr = {};
+ try {
+ tlsr = parseTLSRecord(bytes);
+ if (tlsr.handshake.value.handshakeType.value !== 0x02) {
+ throw new Error();
+ }
+ } catch (err) {
+ throw new OperationError("Data is not a valid TLS Server Hello. QUIC is not yet supported.\n" + err);
+ }
+
+ /* QUIC
+ “q” or “t”, which denotes whether the hello packet is for QUIC or TCP.
+ TODO: Implement QUIC
+ */
+ const ptype = "t";
+
+ /* TLS Version
+ TLS version is shown in 3 different places. If extension 0x002b exists (supported_versions), then the version
+ is the highest value in the extension. Remember to ignore GREASE values. If the extension doesn’t exist, then
+ the TLS version is the value of the Protocol Version. Handshake version (located at the top of the packet)
+ should be ignored.
+ */
+ let version = tlsr.handshake.value.helloVersion.value;
+ for (const ext of tlsr.handshake.value.extensions.value) {
+ if (ext.type.value === "supported_versions") {
+ version = parseHighestSupportedVersion(ext.value.data);
+ break;
+ }
+ }
+ version = tlsVersionMapper(version);
+
+ /* Number of Extensions
+ 2 character number of cipher suites, so if there’s 6 cipher suites in the hello packet, then the value should be “06”.
+ If there’s > 99, which there should never be, then output “99”.
+ */
+ let extLen = tlsr.handshake.value.extensions.value.length;
+ extLen = extLen > 99 ? "99" : extLen.toString().padStart(2, "0");
+
+ /* ALPN Extension Chosen Value
+ The first and last characters of the ALPN (Application-Layer Protocol Negotiation) first value.
+ If there are no ALPN values or no ALPN extension then we print “00” as the value in the fingerprint.
+ */
+ let alpn = "00";
+ for (const ext of tlsr.handshake.value.extensions.value) {
+ if (ext.type.value === "application_layer_protocol_negotiation") {
+ alpn = alpnFingerprint(parseFirstALPNValue(ext.value.data));
+ break;
+ }
+ }
+
+ /* Chosen Cipher
+ The hex value of the chosen cipher suite
+ */
+ const cipher = toHexFast(tlsr.handshake.value.cipherSuite.data);
+
+ /* Extension hash
+ A 12 character truncated sha256 hash of the list of extensions.
+ The extension list is created using the 4 character hex values of the extensions, lower case, comma delimited.
+ */
+ const extensionsList = [];
+ for (const ext of tlsr.handshake.value.extensions.value) {
+ extensionsList.push(toHexFast(ext.type.data));
+ }
+ const extensionsRaw = extensionsList.join(",");
+ const extensionsHash = runHash(
+ "sha256",
+ Utils.strToArrayBuffer(extensionsRaw)
+ ).substring(0, 12);
+
+ return {
+ "JA4S": `${ptype}${version}${extLen}${alpn}_${cipher}_${extensionsHash}`,
+ "JA4S_r": `${ptype}${version}${extLen}${alpn}_${cipher}_${extensionsRaw}`,
+ };
+}
+
+
+/**
+ * Takes a TLS version value and returns a JA4 TLS version string
+ * @param {Uint8Array} version - Two byte array of version number
+ * @returns {string}
+ */
+function tlsVersionMapper(version) {
+ switch (version) {
+ case 0x0304: return "13"; // TLS 1.3
+ case 0x0303: return "12"; // TLS 1.2
+ case 0x0302: return "11"; // TLS 1.1
+ case 0x0301: return "10"; // TLS 1.0
+ case 0x0300: return "s3"; // SSL 3.0
+ case 0x0200: return "s2"; // SSL 2.0
+ case 0x0100: return "s1"; // SSL 1.0
+ default: return "00"; // Unknown
+ }
+}
+
+/**
+ * Checks if a byte is ASCII alphanumeric (0-9, A-Z, a-z).
+ * @param {number} byte
+ * @returns {boolean}
+ */
+function isAlphanumeric(byte) {
+ return (byte >= 0x30 && byte <= 0x39) ||
+ (byte >= 0x41 && byte <= 0x5A) ||
+ (byte >= 0x61 && byte <= 0x7A);
+}
+
+/**
+ * Computes the 2-character ALPN fingerprint from raw ALPN bytes.
+ * If both first and last bytes are ASCII alphanumeric, returns their characters.
+ * Otherwise, returns first hex digit of first byte + last hex digit of last byte.
+ * @param {Uint8Array|null} rawBytes
+ * @returns {string}
+ */
+function alpnFingerprint(rawBytes) {
+ if (!rawBytes || rawBytes.length === 0) return "00";
+ const firstByte = rawBytes[0];
+ const lastByte = rawBytes[rawBytes.length - 1];
+ if (isAlphanumeric(firstByte) && isAlphanumeric(lastByte)) {
+ return String.fromCharCode(firstByte) + String.fromCharCode(lastByte);
+ }
+ const firstHex = firstByte.toString(16).padStart(2, "0");
+ const lastHex = lastByte.toString(16).padStart(2, "0");
+ return firstHex[0] + lastHex[1];
+}
diff --git a/src/core/lib/LZNT1.mjs b/src/core/lib/LZNT1.mjs
new file mode 100644
index 00000000..9a1c7fab
--- /dev/null
+++ b/src/core/lib/LZNT1.mjs
@@ -0,0 +1,88 @@
+/**
+ *
+ * LZNT1 Decompress.
+ *
+ * @author 0xThiebaut [thiebaut.dev]
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ *
+ * https://github.com/Velocidex/go-ntfs/blob/master/parser%2Flznt1.go
+ */
+
+import Utils from "../Utils.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+const COMPRESSED_MASK = 1 << 15,
+ SIZE_MASK = (1 << 12) - 1;
+
+/**
+ * @param {number} offset
+ * @returns {number}
+ */
+function getDisplacement(offset) {
+ let result = 0;
+ while (offset >= 0x10) {
+ offset >>= 1;
+ result += 1;
+ }
+ return result;
+}
+
+/**
+ * @param {byteArray} compressed
+ * @returns {byteArray}
+ */
+export function decompress(compressed) {
+ const decompressed = Array();
+ let coffset = 0;
+
+ while (coffset + 2 <= compressed.length) {
+ const doffset = decompressed.length;
+
+ const blockHeader = Utils.byteArrayToInt(compressed.slice(coffset, coffset + 2), "little");
+ coffset += 2;
+
+ const size = blockHeader & SIZE_MASK;
+ const blockEnd = coffset + size + 1;
+
+ if (size === 0) {
+ break;
+ } else if (compressed.length < coffset + size) {
+ throw new OperationError("Malformed LZNT1 stream: Block too small! Has the stream been truncated?");
+ }
+
+ if ((blockHeader & COMPRESSED_MASK) !== 0) {
+ while (coffset < blockEnd) {
+ let header = compressed[coffset++];
+
+ for (let i = 0; i < 8 && coffset < blockEnd; i++) {
+ if ((header & 1) === 0) {
+ decompressed.push(compressed[coffset++]);
+ } else {
+ const pointer = Utils.byteArrayToInt(compressed.slice(coffset, coffset + 2), "little");
+ coffset += 2;
+
+ const displacement = getDisplacement(decompressed.length - doffset - 1);
+ const symbolOffset = (pointer >> (12 - displacement)) + 1;
+ const symbolLength = (pointer & (0xFFF >> displacement)) + 2;
+ const shiftOffset = decompressed.length - symbolOffset;
+
+ for (let shiftDelta = 0; shiftDelta < symbolLength + 1; shiftDelta++) {
+ const shift = shiftOffset + shiftDelta;
+ if (shift < 0 || decompressed.length <= shift) {
+ throw new OperationError("Malformed LZNT1 stream: Invalid shift!");
+ }
+ decompressed.push(decompressed[shift]);
+ }
+ }
+ header >>= 1;
+ }
+ }
+ } else {
+ decompressed.push(...compressed.slice(coffset, coffset + size + 1));
+ coffset += size + 1;
+ }
+ }
+
+ return decompressed;
+}
diff --git a/src/core/lib/Magic.mjs b/src/core/lib/Magic.mjs
index 921fc3f6..14111ec7 100644
--- a/src/core/lib/Magic.mjs
+++ b/src/core/lib/Magic.mjs
@@ -3,6 +3,7 @@ import Utils, { isWorkerEnvironment } from "../Utils.mjs";
import Recipe from "../Recipe.mjs";
import Dish from "../Dish.mjs";
import {detectFileType, isType} from "./FileType.mjs";
+import {isUTF8} from "./ChrEnc.mjs";
import chiSquared from "chi-squared";
/**
@@ -111,82 +112,6 @@ class Magic {
};
}
- /**
- * Detects whether the input buffer is valid UTF8.
- *
- * @returns {boolean}
- */
- isUTF8() {
- const bytes = new Uint8Array(this.inputBuffer);
- let i = 0;
- while (i < bytes.length) {
- if (( // ASCII
- bytes[i] === 0x09 ||
- bytes[i] === 0x0A ||
- bytes[i] === 0x0D ||
- (0x20 <= bytes[i] && bytes[i] <= 0x7E)
- )) {
- i += 1;
- continue;
- }
-
- if (( // non-overlong 2-byte
- (0xC2 <= bytes[i] && bytes[i] <= 0xDF) &&
- (0x80 <= bytes[i+1] && bytes[i+1] <= 0xBF)
- )) {
- i += 2;
- continue;
- }
-
- if (( // excluding overlongs
- bytes[i] === 0xE0 &&
- (0xA0 <= bytes[i + 1] && bytes[i + 1] <= 0xBF) &&
- (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF)
- ) ||
- ( // straight 3-byte
- ((0xE1 <= bytes[i] && bytes[i] <= 0xEC) ||
- bytes[i] === 0xEE ||
- bytes[i] === 0xEF) &&
- (0x80 <= bytes[i + 1] && bytes[i+1] <= 0xBF) &&
- (0x80 <= bytes[i+2] && bytes[i+2] <= 0xBF)
- ) ||
- ( // excluding surrogates
- bytes[i] === 0xED &&
- (0x80 <= bytes[i+1] && bytes[i+1] <= 0x9F) &&
- (0x80 <= bytes[i+2] && bytes[i+2] <= 0xBF)
- )) {
- i += 3;
- continue;
- }
-
- if (( // planes 1-3
- bytes[i] === 0xF0 &&
- (0x90 <= bytes[i + 1] && bytes[i + 1] <= 0xBF) &&
- (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF) &&
- (0x80 <= bytes[i + 3] && bytes[i + 3] <= 0xBF)
- ) ||
- ( // planes 4-15
- (0xF1 <= bytes[i] && bytes[i] <= 0xF3) &&
- (0x80 <= bytes[i + 1] && bytes[i + 1] <= 0xBF) &&
- (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF) &&
- (0x80 <= bytes[i + 3] && bytes[i + 3] <= 0xBF)
- ) ||
- ( // plane 16
- bytes[i] === 0xF4 &&
- (0x80 <= bytes[i + 1] && bytes[i + 1] <= 0x8F) &&
- (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF) &&
- (0x80 <= bytes[i + 3] && bytes[i + 3] <= 0xBF)
- )) {
- i += 4;
- continue;
- }
-
- return false;
- }
-
- return true;
- }
-
/**
* Calculates the Shannon entropy of the input data.
*
@@ -336,7 +261,7 @@ class Magic {
data: this.inputStr.slice(0, 100),
languageScores: this.detectLanguage(extLang),
fileType: this.detectFileType(),
- isUTF8: this.isUTF8(),
+ isUTF8: !!isUTF8(this.inputBuffer),
entropy: this.calcEntropy(),
matchingOps: matchingOps,
useful: useful,
diff --git a/src/core/lib/Modhex.mjs b/src/core/lib/Modhex.mjs
new file mode 100644
index 00000000..ab4a7c8b
--- /dev/null
+++ b/src/core/lib/Modhex.mjs
@@ -0,0 +1,167 @@
+/**
+ * @author linuxgemini [ilteris@asenkron.com.tr]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Utils from "../Utils.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { fromHex, toHex } from "./Hex.mjs";
+
+/**
+ * Modhex alphabet.
+ */
+const MODHEX_ALPHABET = "cbdefghijklnrtuv";
+
+
+/**
+ * Modhex alphabet map.
+ */
+const MODHEX_ALPHABET_MAP = MODHEX_ALPHABET.split("");
+
+
+/**
+ * Hex alphabet to substitute Modhex.
+ */
+const HEX_ALPHABET = "0123456789abcdef";
+
+
+/**
+ * Hex alphabet map to substitute Modhex.
+ */
+const HEX_ALPHABET_MAP = HEX_ALPHABET.split("");
+
+
+/**
+ * Convert a byte array into a modhex string.
+ *
+ * @param {byteArray|Uint8Array|ArrayBuffer} data
+ * @param {string} [delim=" "]
+ * @param {number} [padding=2]
+ * @returns {string}
+ *
+ * @example
+ * // returns "cl bf bu"
+ * toModhex([10,20,30]);
+ *
+ * // returns "cl:bf:bu"
+ * toModhex([10,20,30], ":");
+ */
+export function toModhex(data, delim=" ", padding=2, extraDelim="", lineSize=0) {
+ if (!data) return "";
+ if (data instanceof ArrayBuffer) data = new Uint8Array(data);
+ if (data.length === 0) return "";
+
+ const regularHexString = toHex(data, "", padding, "", 0);
+
+ let modhexString = "";
+ for (const letter of regularHexString.split("")) {
+ modhexString += MODHEX_ALPHABET_MAP[HEX_ALPHABET_MAP.indexOf(letter)];
+ }
+
+ let output = "";
+ const groupingRegexp = new RegExp(`.{1,${padding}}`, "g");
+ const groupedModhex = modhexString.match(groupingRegexp);
+
+ for (let i = 0; i < groupedModhex.length; i++) {
+ const group = groupedModhex[i];
+ output += group + delim;
+
+ if (extraDelim) {
+ output += extraDelim;
+ }
+ // Add LF after each lineSize amount of bytes but not at the end
+ if ((i !== groupedModhex.length - 1) && ((i + 1) % lineSize === 0)) {
+ output += "\n";
+ }
+ }
+
+ // Remove the extraDelim at the end (if there is one)
+ // and remove the delim at the end, but if it's prepended there's nothing to remove
+ const rTruncLen = extraDelim.length + delim.length;
+ if (rTruncLen) {
+ // If rTruncLen === 0 then output.slice(0,0) will be returned, which is nothing
+ return output.slice(0, -rTruncLen);
+ } else {
+ return output;
+ }
+}
+
+
+/**
+ * Convert a byte array into a modhex string as efficiently as possible with no options.
+ *
+ * @param {byteArray|Uint8Array|ArrayBuffer} data
+ * @returns {string}
+ *
+ * @example
+ * // returns "clbfbu"
+ * toModhexFast([10,20,30]);
+ */
+export function toModhexFast(data) {
+ if (!data) return "";
+ if (data instanceof ArrayBuffer) data = new Uint8Array(data);
+ if (data.length === 0) return "";
+
+ const output = [];
+
+ for (let i = 0; i < data.length; i++) {
+ output.push(MODHEX_ALPHABET_MAP[(data[i] >> 4) & 0xf]);
+ output.push(MODHEX_ALPHABET_MAP[data[i] & 0xf]);
+ }
+ return output.join("");
+}
+
+
+/**
+ * Convert a modhex string into a byte array.
+ *
+ * @param {string} data
+ * @param {string} [delim]
+ * @param {number} [byteLen=2]
+ * @returns {byteArray}
+ *
+ * @example
+ * // returns [10,20,30]
+ * fromModhex("cl bf bu");
+ *
+ * // returns [10,20,30]
+ * fromModhex("cl:bf:bu", "Colon");
+ */
+export function fromModhex(data, delim="Auto", byteLen=2) {
+ if (byteLen < 1 || Math.round(byteLen) !== byteLen)
+ throw new OperationError("Byte length must be a positive integer");
+
+ // The `.replace(/\s/g, "")` an interesting workaround: Hex "multiline" tests aren't actually
+ // multiline. Tests for Modhex fixes that, thus exposing the issue.
+ data = data.toLowerCase().replace(/\s/g, "");
+
+ if (delim !== "None") {
+ const delimRegex = delim === "Auto" ? /[^cbdefghijklnrtuv]/gi : Utils.regexRep(delim);
+ data = data.split(delimRegex);
+ } else {
+ data = [data];
+ }
+
+ let regularHexString = "";
+ for (let i = 0; i < data.length; i++) {
+ for (const letter of data[i].split("")) {
+ regularHexString += HEX_ALPHABET_MAP[MODHEX_ALPHABET_MAP.indexOf(letter)];
+ }
+ }
+
+ const output = fromHex(regularHexString, "None", byteLen);
+ return output;
+}
+
+
+/**
+ * To Modhex delimiters.
+ */
+export const TO_MODHEX_DELIM_OPTIONS = ["Space", "Percent", "Comma", "Semi-colon", "Colon", "Line feed", "CRLF", "None"];
+
+
+/**
+ * From Modhex delimiters.
+ */
+export const FROM_MODHEX_DELIM_OPTIONS = ["Auto"].concat(TO_MODHEX_DELIM_OPTIONS);
diff --git a/src/core/lib/ParityBit.mjs b/src/core/lib/ParityBit.mjs
new file mode 100644
index 00000000..9675b46c
--- /dev/null
+++ b/src/core/lib/ParityBit.mjs
@@ -0,0 +1,50 @@
+/**
+ * Parity Bit functions.
+ *
+ * @author j83305 [awz22@protonmail.com]
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ *
+ */
+
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Function to take the user input and encode using the given arguments
+ * @param input string of binary
+ * @param args array
+ */
+export function calculateParityBit(input, args) {
+ let count1s = 0;
+ for (let i = 0; i < input.length; i++) {
+ const character = input.charAt(i);
+ if (character === "1") {
+ count1s++;
+ } else if (character !== args[3] && character !== "0" && character !== " ") {
+ throw new OperationError("unexpected character encountered: \"" + character + "\"");
+ }
+ }
+ let parityBit = "1";
+ const flipflop = args[0] === "Even Parity" ? 0 : 1;
+ if (count1s % 2 === flipflop) {
+ parityBit = "0";
+ }
+ if (args[1] === "End") {
+ return input + parityBit;
+ } else {
+ return parityBit + input;
+ }
+}
+
+/**
+ * just removes the parity bit to return the original data
+ * @param input string of binary, encoded
+ * @param args array
+ */
+export function decodeParityBit(input, args) {
+ if (args[1] === "End") {
+ return input.slice(0, -1);
+ } else {
+ return input.slice(1);
+ }
+}
diff --git a/src/core/lib/Protocol.mjs b/src/core/lib/Protocol.mjs
index 57d2374a..dfb8b197 100644
--- a/src/core/lib/Protocol.mjs
+++ b/src/core/lib/Protocol.mjs
@@ -26,6 +26,9 @@ export function objToTable(obj, nested=false) {
`;
for (const key in obj) {
+ if (typeof obj[key] === "function")
+ continue;
+
html += `${key} `;
if (typeof obj[key] === "object")
html += `${objToTable(obj[key], true)} `;
diff --git a/src/core/lib/QRCode.mjs b/src/core/lib/QRCode.mjs
index cc829002..43f9ec9a 100644
--- a/src/core/lib/QRCode.mjs
+++ b/src/core/lib/QRCode.mjs
@@ -10,8 +10,7 @@ import OperationError from "../errors/OperationError.mjs";
import jsQR from "jsqr";
import qr from "qr-image";
import Utils from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import { Jimp, JimpMime } from "jimp";
/**
* Parses a QR code image from an image
@@ -23,25 +22,38 @@ const jimp = jimplib.default ? jimplib.default : jimplib;
export async function parseQrCode(input, normalise) {
let image;
try {
- image = await jimp.read(input);
+ image = await Jimp.read(input);
} catch (err) {
throw new OperationError(`Error opening image. (${err})`);
}
try {
if (normalise) {
- image.rgba(false);
- image.background(0xFFFFFFFF);
- image.normalize();
image.greyscale();
- image = await image.getBufferAsync(jimp.MIME_JPEG);
- image = await jimp.read(image);
+ image.normalize();
}
} catch (err) {
throw new OperationError(`Error normalising image. (${err})`);
}
- const qrData = jsQR(image.bitmap.data, image.getWidth(), image.getHeight());
+ // Remove transparency which jsQR cannot handle
+ image.scan((x, y, idx) => {
+ // If pixel is fully transparent, make it opaque white
+ if (image.bitmap.data[idx + 3] === 0x00) {
+ image.bitmap.data[idx + 0] = 0xff;
+ image.bitmap.data[idx + 1] = 0xff;
+ image.bitmap.data[idx + 2] = 0xff;
+ }
+ // Otherwise, make it fully opaque at its existing colour
+ image.bitmap.data[idx + 3] = 0xff;
+ });
+ image = await Jimp.read(await image.getBuffer(JimpMime.jpeg));
+
+ const qrData = jsQR(
+ new Uint8ClampedArray(image.bitmap.data),
+ image.width,
+ image.height,
+ );
if (qrData) {
return qrData.data;
} else {
@@ -59,7 +71,13 @@ export async function parseQrCode(input, normalise) {
* @param {string} errorCorrection
* @returns {ArrayBuffer}
*/
-export function generateQrCode(input, format, moduleSize, margin, errorCorrection) {
+export function generateQrCode(
+ input,
+ format,
+ moduleSize,
+ margin,
+ errorCorrection,
+) {
const formats = ["SVG", "EPS", "PDF", "PNG"];
if (!formats.includes(format.toUpperCase())) {
throw new OperationError("Unsupported QR code format.");
@@ -71,7 +89,8 @@ export function generateQrCode(input, format, moduleSize, margin, errorCorrectio
type: format,
size: moduleSize,
margin: margin,
- "ec_level": errorCorrection.charAt(0).toUpperCase()
+ // eslint-disable-next-line camelcase
+ ec_level: errorCorrection.charAt(0).toUpperCase(),
});
} catch (err) {
throw new OperationError(`Error generating QR code. (${err})`);
@@ -87,7 +106,7 @@ export function generateQrCode(input, format, moduleSize, margin, errorCorrectio
case "PDF":
return Utils.strToArrayBuffer(qrImage);
case "PNG":
- return qrImage.buffer;
+ return qrImage.buffer.slice(qrImage.byteOffset, qrImage.byteLength + qrImage.byteOffset);
default:
throw new OperationError("Unsupported QR code format.");
}
diff --git a/src/core/lib/RC6.mjs b/src/core/lib/RC6.mjs
new file mode 100644
index 00000000..eaa6087c
--- /dev/null
+++ b/src/core/lib/RC6.mjs
@@ -0,0 +1,625 @@
+/**
+ * Complete implementation of RC6 block cipher encryption/decryption with
+ * configurable word size (w), rounds (r), and key length (b).
+ *
+ * RC6 was an AES finalist designed by Ron Rivest, Matt Robshaw, Ray Sidney, and Yiqun Lisa Yin.
+ * Reference: https://en.wikipedia.org/wiki/RC6
+ * Test Vectors: https://datatracker.ietf.org/doc/html/draft-krovetz-rc6-rc5-vectors-00
+ *
+ * The P and Q constants are derived from mathematical constants e (Euler's number) and
+ * φ (golden ratio) as specified in the IETF draft. Master 256-bit values are scaled to
+ * any word size.
+ *
+ * @author Medjedtxm
+ * @copyright Crown Copyright 2026
+ * @license Apache-2.0
+ */
+
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Master P constant (256-bit) from IETF draft-krovetz-rc6-rc5-vectors-00
+ * Derived from Odd((e-2) * 2^256) where e = 2.71828...
+ */
+const P_256 = 0xb7e151628aed2a6abf7158809cf4f3c762e7160f38b4da56a784d9045190cfefn;
+
+/**
+ * Master Q constant (256-bit) from IETF draft-krovetz-rc6-rc5-vectors-00
+ * Derived from Odd((φ-1) * 2^256) where φ = 1.61803... (golden ratio)
+ */
+const Q_256 = 0x9e3779b97f4a7c15f39cc0605cedc8341082276bf3a27251f86c6a11d0c18e95n;
+
+/**
+ * Get P constant for given word size by scaling the 256-bit master constant
+ * @param {number} w - Word size in bits
+ * @returns {bigint} - P constant for word size w
+ */
+function getP(w) {
+ return (P_256 >> BigInt(256 - w)) | 1n; // Ensure odd
+}
+
+/**
+ * Get Q constant for given word size by scaling the 256-bit master constant
+ * @param {number} w - Word size in bits
+ * @returns {bigint} - Q constant for word size w
+ */
+function getQ(w) {
+ return (Q_256 >> BigInt(256 - w)) | 1n; // Ensure odd
+}
+
+/**
+ * Get block size in bytes for given word size
+ * Block size = 4 words = 4 * (w/8) bytes
+ * @param {number} w - Word size in bits
+ * @returns {number} - Block size in bytes
+ */
+export function getBlockSize(w) {
+ return 4 * (w / 8);
+}
+
+/**
+ * Get recommended number of rounds for given word size
+ * @param {number} w - Word size in bits
+ * @returns {number} - Recommended rounds
+ */
+export function getDefaultRounds(w) {
+ if (w <= 16) return 16;
+ if (w <= 32) return 20;
+ if (w <= 64) return 24;
+ return 28;
+}
+
+/**
+ * Create mask for w-bit word
+ * @param {number} w - Word size in bits
+ * @returns {bigint} - Mask with w bits set
+ */
+function wordMask(w) {
+ return (1n << BigInt(w)) - 1n;
+}
+
+/**
+ * Rotate left for arbitrary word size using BigInt
+ * Uses lower lg(w) bits of n for rotation amount (RC6 spec)
+ * @param {bigint} x - Value to rotate
+ * @param {bigint} n - Rotation amount
+ * @param {number} w - Word size in bits
+ * @param {bigint} lgMask - Mask for lower lg(w) bits
+ * @returns {bigint} - Rotated value
+ */
+function ROL(x, n, w, lgMask) {
+ const mask = wordMask(w);
+ // Mask to lg(w) bits, then mod w for non-power-of-2 word sizes
+ // For power-of-2, (n & lgMask) < w always, so mod w is no-op
+ const shift = (n & lgMask) % BigInt(w);
+ return ((x << shift) | (x >> (BigInt(w) - shift))) & mask;
+}
+
+/**
+ * Rotate right for arbitrary word size using BigInt
+ * Uses lower lg(w) bits of n for rotation amount (RC6 spec)
+ * @param {bigint} x - Value to rotate
+ * @param {bigint} n - Rotation amount
+ * @param {number} w - Word size in bits
+ * @param {bigint} lgMask - Mask for lower lg(w) bits
+ * @returns {bigint} - Rotated value
+ */
+function ROR(x, n, w, lgMask) {
+ const mask = wordMask(w);
+ // Mask to lg(w) bits, then mod w for non-power-of-2 word sizes
+ // For power-of-2, (n & lgMask) < w always, so mod w is no-op
+ const shift = (n & lgMask) % BigInt(w);
+ return ((x >> shift) | (x << (BigInt(w) - shift))) & mask;
+}
+
+/**
+ * Convert byte array to word array (little-endian) using BigInt
+ * @param {number[]} bytes - Input byte array
+ * @param {number} w - Word size in bits
+ * @returns {bigint[]} - Array of w-bit words as BigInt
+ */
+function bytesToWords(bytes, w) {
+ const bytesPerWord = w / 8;
+ const words = [];
+ for (let i = 0; i < bytes.length; i += bytesPerWord) {
+ let word = 0n;
+ for (let j = 0; j < bytesPerWord && (i + j) < bytes.length; j++) {
+ word |= BigInt(bytes[i + j] || 0) << BigInt(j * 8);
+ }
+ words.push(word);
+ }
+ return words;
+}
+
+/**
+ * Convert word array to byte array (little-endian) using BigInt
+ * @param {bigint[]} words - Array of words
+ * @param {number} w - Word size in bits
+ * @returns {number[]} - Output byte array
+ */
+function wordsToBytes(words, w) {
+ const bytesPerWord = w / 8;
+ const bytes = [];
+ for (const word of words) {
+ for (let j = 0; j < bytesPerWord; j++) {
+ bytes.push(Number((word >> BigInt(j * 8)) & 0xFFn));
+ }
+ }
+ return bytes;
+}
+
+/**
+ * Generate round subkeys from user key
+ *
+ * @param {number[]} key - User key as byte array
+ * @param {number} rounds - Number of rounds
+ * @param {number} w - Word size in bits
+ * @returns {bigint[]} - Array of 2r+4 subkeys as BigInt
+ */
+function generateSubkeys(key, rounds, w) {
+ const bytesPerWord = w / 8;
+ const b = key.length;
+ const c = Math.max(Math.ceil(b / bytesPerWord), 1);
+
+ // Convert key bytes to words, pad with zeros if needed
+ const paddedKey = [...key];
+ while (paddedKey.length < c * bytesPerWord) {
+ paddedKey.push(0);
+ }
+ const L = bytesToWords(paddedKey, w);
+
+ // Number of subkeys: 2*r + 4
+ const t = 2 * rounds + 4;
+
+ // Get P and Q for this word size
+ const P = getP(w);
+ const Q = getQ(w);
+ const mask = wordMask(w);
+
+ // lg(w) mask for rotation amounts (floor of log2(w), per RC6 spec)
+ const lgw = Math.floor(Math.log2(w));
+ const lgMask = (1n << BigInt(lgw)) - 1n;
+
+ // Initialise S array with magic constants
+ const S = new Array(t);
+ S[0] = P;
+ for (let i = 1; i < t; i++) {
+ S[i] = (S[i - 1] + Q) & mask;
+ }
+
+ // Mix key into S
+ let A = 0n, B = 0n;
+ let i = 0, j = 0;
+ const v = 3 * Math.max(c, t);
+
+ for (let s = 0; s < v; s++) {
+ A = S[i] = ROL((S[i] + A + B) & mask, 3n, w, lgMask);
+ B = L[j] = ROL((L[j] + A + B) & mask, A + B, w, lgMask);
+ i = (i + 1) % t;
+ j = (j + 1) % c;
+ }
+
+ return S;
+}
+
+/**
+ * Encrypt a single block using RC6
+ *
+ * @param {number[]} block - Plaintext block (4*w/8 bytes)
+ * @param {bigint[]} S - Subkeys array
+ * @param {number} rounds - Number of rounds
+ * @param {number} w - Word size in bits
+ * @returns {number[]} - Ciphertext block
+ */
+function encryptBlock(block, S, rounds, w) {
+ const mask = wordMask(w);
+ const lgw = BigInt(Math.floor(Math.log2(w)));
+ const lgMask = (1n << lgw) - 1n;
+
+ // Convert block to 4 words (A, B, C, D)
+ let [A, B, C, D] = bytesToWords(block, w);
+
+ // Pre-whitening
+ B = (B + S[0]) & mask;
+ D = (D + S[1]) & mask;
+
+ // Main rounds
+ for (let i = 1; i <= rounds; i++) {
+ // t = ROL(B * (2B + 1), lg(w))
+ const t = ROL((B * ((2n * B + 1n) & mask)) & mask, lgw, w, lgMask);
+
+ // u = ROL(D * (2D + 1), lg(w))
+ const u = ROL((D * ((2n * D + 1n) & mask)) & mask, lgw, w, lgMask);
+
+ // A = ROL(A ^ t, u) + S[2i]
+ A = (ROL(A ^ t, u, w, lgMask) + S[2 * i]) & mask;
+
+ // C = ROL(C ^ u, t) + S[2i + 1]
+ C = (ROL(C ^ u, t, w, lgMask) + S[2 * i + 1]) & mask;
+
+ // Rotate registers: (A, B, C, D) = (B, C, D, A)
+ const temp = A;
+ A = B;
+ B = C;
+ C = D;
+ D = temp;
+ }
+
+ // Post-whitening
+ A = (A + S[2 * rounds + 2]) & mask;
+ C = (C + S[2 * rounds + 3]) & mask;
+
+ // Convert words back to bytes
+ return wordsToBytes([A, B, C, D], w);
+}
+
+/**
+ * Decrypt a single block using RC6
+ *
+ * @param {number[]} block - Ciphertext block (4*w/8 bytes)
+ * @param {bigint[]} S - Subkeys array
+ * @param {number} rounds - Number of rounds
+ * @param {number} w - Word size in bits
+ * @returns {number[]} - Plaintext block
+ */
+function decryptBlock(block, S, rounds, w) {
+ const mask = wordMask(w);
+ const lgw = BigInt(Math.floor(Math.log2(w)));
+ const lgMask = (1n << lgw) - 1n;
+
+ // Convert block to 4 words (A, B, C, D)
+ let [A, B, C, D] = bytesToWords(block, w);
+
+ // Reverse post-whitening
+ C = (C - S[2 * rounds + 3] + (1n << BigInt(w))) & mask;
+ A = (A - S[2 * rounds + 2] + (1n << BigInt(w))) & mask;
+
+ // Main rounds in reverse
+ for (let i = rounds; i >= 1; i--) {
+ // Reverse rotate registers: (A, B, C, D) = (D, A, B, C)
+ const temp = D;
+ D = C;
+ C = B;
+ B = A;
+ A = temp;
+
+ // u = ROL(D * (2D + 1), lg(w))
+ const u = ROL((D * ((2n * D + 1n) & mask)) & mask, lgw, w, lgMask);
+
+ // t = ROL(B * (2B + 1), lg(w))
+ const t = ROL((B * ((2n * B + 1n) & mask)) & mask, lgw, w, lgMask);
+
+ // C = ROR(C - S[2i + 1], t) ^ u
+ C = ROR((C - S[2 * i + 1] + (1n << BigInt(w))) & mask, t, w, lgMask) ^ u;
+
+ // A = ROR(A - S[2i], u) ^ t
+ A = ROR((A - S[2 * i] + (1n << BigInt(w))) & mask, u, w, lgMask) ^ t;
+ }
+
+ // Reverse pre-whitening
+ D = (D - S[1] + (1n << BigInt(w))) & mask;
+ B = (B - S[0] + (1n << BigInt(w))) & mask;
+
+ // Convert words back to bytes
+ return wordsToBytes([A, B, C, D], w);
+}
+
+/**
+ * XOR two blocks
+ * @param {number[]} a - First block
+ * @param {number[]} b - Second block
+ * @returns {number[]} - XOR result
+ */
+function xorBlocks(a, b) {
+ const result = new Array(a.length);
+ for (let i = 0; i < a.length; i++) {
+ result[i] = a[i] ^ b[i];
+ }
+ return result;
+}
+
+/**
+ * Increment counter (little-endian)
+ * @param {number[]} counter - Counter block
+ * @returns {number[]} - Incremented counter
+ */
+function incrementCounter(counter) {
+ const result = [...counter];
+ for (let i = 0; i < result.length; i++) {
+ result[i]++;
+ if (result[i] <= 255) break;
+ result[i] = 0;
+ }
+ return result;
+}
+
+/**
+ * Apply padding to message
+ * @param {number[]} message - Original message
+ * @param {string} padding - Padding type ("NO", "PKCS5", "ZERO", "RANDOM", "BIT")
+ * @param {number} blockSize - Block size in bytes
+ * @returns {number[]} - Padded message
+ */
+function applyPadding(message, padding, blockSize) {
+ const remainder = message.length % blockSize;
+ let nPadding = remainder === 0 ? 0 : blockSize - remainder;
+
+ // For PKCS5, always add at least one byte (full block if already aligned)
+ if (padding === "PKCS5" && remainder === 0) {
+ nPadding = blockSize;
+ }
+
+ if (nPadding === 0) return [...message];
+
+ const paddedMessage = [...message];
+
+ switch (padding) {
+ case "NO":
+ throw new OperationError(`No padding requested but input is not a ${blockSize}-byte multiple.`);
+
+ case "PKCS5":
+ for (let i = 0; i < nPadding; i++) {
+ paddedMessage.push(nPadding);
+ }
+ break;
+
+ case "ZERO":
+ for (let i = 0; i < nPadding; i++) {
+ paddedMessage.push(0);
+ }
+ break;
+
+ case "RANDOM":
+ for (let i = 0; i < nPadding; i++) {
+ paddedMessage.push(Math.floor(Math.random() * 256));
+ }
+ break;
+
+ case "BIT":
+ paddedMessage.push(0x80);
+ for (let i = 1; i < nPadding; i++) {
+ paddedMessage.push(0);
+ }
+ break;
+
+ default:
+ throw new OperationError(`Unknown padding type: ${padding}`);
+ }
+
+ return paddedMessage;
+}
+
+/**
+ * Remove padding from message
+ * @param {number[]} message - Padded message
+ * @param {string} padding - Padding type ("NO", "PKCS5", "ZERO", "RANDOM", "BIT")
+ * @param {number} blockSize - Block size in bytes
+ * @returns {number[]} - Unpadded message
+ */
+function removePadding(message, padding, blockSize) {
+ if (message.length === 0) return message;
+
+ switch (padding) {
+ case "NO":
+ case "ZERO":
+ case "RANDOM":
+ // These padding types cannot be reliably removed
+ return message;
+
+ case "PKCS5": {
+ const padByte = message[message.length - 1];
+ if (padByte > 0 && padByte <= blockSize) {
+ // Verify padding
+ for (let i = 0; i < padByte; i++) {
+ if (message[message.length - 1 - i] !== padByte) {
+ throw new OperationError("Invalid PKCS#5 padding.");
+ }
+ }
+ return message.slice(0, message.length - padByte);
+ }
+ throw new OperationError("Invalid PKCS#5 padding.");
+ }
+
+ case "BIT": {
+ // Find 0x80 byte working backwards, skipping zeros
+ for (let i = message.length - 1; i >= 0; i--) {
+ if (message[i] === 0x80) {
+ return message.slice(0, i);
+ } else if (message[i] !== 0) {
+ throw new OperationError("Invalid BIT padding.");
+ }
+ }
+ throw new OperationError("Invalid BIT padding.");
+ }
+
+ default:
+ throw new OperationError(`Unknown padding type: ${padding}`);
+ }
+}
+
+/**
+ * Encrypt using RC6 cipher with specified block mode
+ *
+ * @param {number[]} message - Plaintext as byte array
+ * @param {number[]} key - Key as byte array
+ * @param {number[]} iv - IV (block size bytes, not used for ECB)
+ * @param {string} mode - Block cipher mode ("ECB", "CBC", "CFB", "OFB", "CTR")
+ * @param {string} padding - Padding type ("NO", "PKCS5", "ZERO", "RANDOM", "BIT")
+ * @param {number} rounds - Number of rounds (default: 20)
+ * @param {number} w - Word size in bits (default: 32)
+ * @returns {number[]} - Ciphertext as byte array
+ */
+export function encryptRC6(message, key, iv, mode = "ECB", padding = "PKCS5", rounds = 20, w = 32) {
+ const blockSize = getBlockSize(w);
+ const messageLength = message.length;
+ if (messageLength === 0) return [];
+
+ const S = generateSubkeys(key, rounds, w);
+
+ // Apply padding for ECB/CBC modes
+ let paddedMessage;
+ if (mode === "ECB" || mode === "CBC") {
+ paddedMessage = applyPadding(message, padding, blockSize);
+ } else {
+ // Stream modes (CFB, OFB, CTR) don't need padding
+ paddedMessage = [...message];
+ }
+
+ const cipherText = [];
+
+ switch (mode) {
+ case "ECB":
+ for (let i = 0; i < paddedMessage.length; i += blockSize) {
+ const block = paddedMessage.slice(i, i + blockSize);
+ cipherText.push(...encryptBlock(block, S, rounds, w));
+ }
+ break;
+
+ case "CBC": {
+ let ivBlock = [...iv];
+ for (let i = 0; i < paddedMessage.length; i += blockSize) {
+ const block = paddedMessage.slice(i, i + blockSize);
+ const xored = xorBlocks(block, ivBlock);
+ ivBlock = encryptBlock(xored, S, rounds, w);
+ cipherText.push(...ivBlock);
+ }
+ break;
+ }
+
+ case "CFB": {
+ let ivBlock = [...iv];
+ for (let i = 0; i < paddedMessage.length; i += blockSize) {
+ const encrypted = encryptBlock(ivBlock, S, rounds, w);
+ const block = paddedMessage.slice(i, i + blockSize);
+ // Pad block if shorter than blockSize
+ while (block.length < blockSize) block.push(0);
+ ivBlock = xorBlocks(encrypted, block);
+ cipherText.push(...ivBlock);
+ }
+ return cipherText.slice(0, messageLength);
+ }
+
+ case "OFB": {
+ let ivBlock = [...iv];
+ for (let i = 0; i < paddedMessage.length; i += blockSize) {
+ ivBlock = encryptBlock(ivBlock, S, rounds, w);
+ const block = paddedMessage.slice(i, i + blockSize);
+ // Pad block if shorter than blockSize
+ while (block.length < blockSize) block.push(0);
+ cipherText.push(...xorBlocks(ivBlock, block));
+ }
+ return cipherText.slice(0, messageLength);
+ }
+
+ case "CTR": {
+ let counter = [...iv];
+ for (let i = 0; i < paddedMessage.length; i += blockSize) {
+ const encrypted = encryptBlock(counter, S, rounds, w);
+ const block = paddedMessage.slice(i, i + blockSize);
+ // Pad block if shorter than blockSize
+ while (block.length < blockSize) block.push(0);
+ cipherText.push(...xorBlocks(encrypted, block));
+ counter = incrementCounter(counter);
+ }
+ return cipherText.slice(0, messageLength);
+ }
+
+ default:
+ throw new OperationError(`Invalid block cipher mode: ${mode}`);
+ }
+
+ return cipherText;
+}
+
+/**
+ * Decrypt using RC6 cipher with specified block mode
+ *
+ * @param {number[]} cipherText - Ciphertext as byte array
+ * @param {number[]} key - Key as byte array
+ * @param {number[]} iv - IV (block size bytes, not used for ECB)
+ * @param {string} mode - Block cipher mode ("ECB", "CBC", "CFB", "OFB", "CTR")
+ * @param {string} padding - Padding type ("NO", "PKCS5", "ZERO", "RANDOM", "BIT")
+ * @param {number} rounds - Number of rounds (default: 20)
+ * @param {number} w - Word size in bits (default: 32)
+ * @returns {number[]} - Plaintext as byte array
+ */
+export function decryptRC6(cipherText, key, iv, mode = "ECB", padding = "PKCS5", rounds = 20, w = 32) {
+ const blockSize = getBlockSize(w);
+ const originalLength = cipherText.length;
+ if (originalLength === 0) return [];
+
+ const S = generateSubkeys(key, rounds, w);
+
+ if (mode === "ECB" || mode === "CBC") {
+ if ((originalLength % blockSize) !== 0)
+ throw new OperationError(`Invalid ciphertext length: ${originalLength} bytes. Must be a multiple of ${blockSize}.`);
+ } else {
+ // Pad for stream modes
+ while ((cipherText.length % blockSize) !== 0)
+ cipherText.push(0);
+ }
+
+ const plainText = [];
+
+ switch (mode) {
+ case "ECB":
+ for (let i = 0; i < cipherText.length; i += blockSize) {
+ const block = cipherText.slice(i, i + blockSize);
+ plainText.push(...decryptBlock(block, S, rounds, w));
+ }
+ break;
+
+ case "CBC": {
+ let ivBlock = [...iv];
+ for (let i = 0; i < cipherText.length; i += blockSize) {
+ const block = cipherText.slice(i, i + blockSize);
+ const decrypted = decryptBlock(block, S, rounds, w);
+ plainText.push(...xorBlocks(decrypted, ivBlock));
+ ivBlock = block;
+ }
+ break;
+ }
+
+ case "CFB": {
+ let ivBlock = [...iv];
+ for (let i = 0; i < cipherText.length; i += blockSize) {
+ const encrypted = encryptBlock(ivBlock, S, rounds, w);
+ const block = cipherText.slice(i, i + blockSize);
+ plainText.push(...xorBlocks(encrypted, block));
+ ivBlock = block;
+ }
+ return plainText.slice(0, originalLength);
+ }
+
+ case "OFB": {
+ let ivBlock = [...iv];
+ for (let i = 0; i < cipherText.length; i += blockSize) {
+ ivBlock = encryptBlock(ivBlock, S, rounds, w);
+ const block = cipherText.slice(i, i + blockSize);
+ plainText.push(...xorBlocks(ivBlock, block));
+ }
+ return plainText.slice(0, originalLength);
+ }
+
+ case "CTR": {
+ let counter = [...iv];
+ for (let i = 0; i < cipherText.length; i += blockSize) {
+ const encrypted = encryptBlock(counter, S, rounds, w);
+ const block = cipherText.slice(i, i + blockSize);
+ plainText.push(...xorBlocks(encrypted, block));
+ counter = incrementCounter(counter);
+ }
+ return plainText.slice(0, originalLength);
+ }
+
+ default:
+ throw new OperationError(`Invalid block cipher mode: ${mode}`);
+ }
+
+ // Remove padding for ECB/CBC modes
+ if (mode === "ECB" || mode === "CBC") {
+ return removePadding(plainText, padding, blockSize);
+ }
+
+ return plainText.slice(0, originalLength);
+}
diff --git a/src/core/lib/SM2.mjs b/src/core/lib/SM2.mjs
new file mode 100644
index 00000000..e8156410
--- /dev/null
+++ b/src/core/lib/SM2.mjs
@@ -0,0 +1,258 @@
+/**
+ * Utilities and operations utilized for SM2 encryption and decryption
+ * @author flakjacket95 [dflack95@gmail.com]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import OperationError from "../errors/OperationError.mjs";
+import { fromHex } from "../lib/Hex.mjs";
+import Utils from "../Utils.mjs";
+import Sm3 from "crypto-api/src/hasher/sm3.mjs";
+import {toHex} from "crypto-api/src/encoder/hex.mjs";
+import r from "jsrsasign";
+
+/**
+ * SM2 Class for encryption and decryption operations
+ */
+export class SM2 {
+ /**
+ * Constructor for SM2 class; sets up with the curve and the output format as specified in user args
+ *
+ * @param {*} curve
+ * @param {*} format
+ */
+ constructor(curve, format) {
+ this.ecParams = null;
+ this.rng = new r.SecureRandom();
+ /*
+ For any additional curve definitions utilized by SM2, add another block like the below for that curve, then add the curve name to the Curve selection dropdown
+ */
+ r.crypto.ECParameterDB.regist(
+ "sm2p256v1", // name / p = 2**256 - 2**224 - 2**96 + 2**64 - 1
+ 256,
+ "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF", // p
+ "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC", // a
+ "28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93", // b
+ "FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123", // n
+ "1", // h
+ "32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7", // gx
+ "BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0", // gy
+ []
+ ); // alias
+ this.ecParams = r.crypto.ECParameterDB.getByName(curve);
+
+ this.format = format;
+ }
+
+ /**
+ * Set the public key coordinates for the SM2 class
+ *
+ * @param {string} publicKeyX
+ * @param {string} publicKeyY
+ */
+ setPublicKey(publicKeyX, publicKeyY) {
+ /*
+ * TODO: This needs some additional length validation; and checking for errors in the decoding process
+ * TODO: Can probably support other public key encoding methods here as well in the future
+ */
+ this.publicKey = this.ecParams.curve.decodePointHex("04" + publicKeyX + publicKeyY);
+
+ if (this.publicKey.isInfinity()) {
+ throw new OperationError("Invalid Public Key");
+ }
+ }
+
+ /**
+ * Set the private key value for the SM2 class
+ *
+ * @param {string} privateKey
+ */
+ setPrivateKey(privateKeyHex) {
+ this.privateKey = new r.BigInteger(privateKeyHex, 16);
+ }
+
+ /**
+ * Main encryption function; takes user input, processes encryption and returns the result in hex (with the components arranged as configured by the user args)
+ *
+ * @param {*} input
+ * @returns {string}
+ */
+ encrypt(input) {
+ const G = this.ecParams.G;
+
+ /*
+ * Compute a new, random public key along the same elliptic curve to form the starting point for our encryption process (record the resulting X and Y as hex to provide as part of the operation output)
+ * k: Randomly generated BigInteger
+ * c1: Result of dotting our curve generator point `G` with the value of `k`
+ */
+ const k = this.generatePublicKey();
+ const c1 = G.multiply(k);
+ const [hexC1X, hexC1Y] = this.getPointAsHex(c1);
+
+ /*
+ * Compute p2 (secret) using the public key, and the chosen k value above
+ */
+ const p2 = this.publicKey.multiply(k);
+
+ /*
+ * Compute the C3 SM3 hash before we transform the array
+ */
+ const c3 = this.c3(p2, input);
+
+ /*
+ * Genreate a proper length encryption key, XOR iteratively, and convert newly encrypted data to hex
+ */
+ const key = this.kdf(p2, input.byteLength);
+ for (let i = 0; i < input.byteLength; i++) {
+ input[i] ^= Utils.ord(key[i]);
+ }
+ const c2 = Buffer.from(input).toString("hex");
+
+ /*
+ * Check user input specs; order the output components as selected
+ */
+ if (this.format === "C1C3C2") {
+ return hexC1X + hexC1Y + c3 + c2;
+ } else {
+ return hexC1X + hexC1Y + c2 + c3;
+ }
+ }
+ /**
+ * Function to decrypt an SM2 encrypted message
+ *
+ * @param {*} input
+ */
+ decrypt(input) {
+ const c1X = input.slice(0, 64);
+ const c1Y = input.slice(64, 128);
+
+ let c3 = "";
+ let c2 = "";
+
+ if (this.format === "C1C3C2") {
+ c3 = input.slice(128, 192);
+ c2 = input.slice(192);
+ } else {
+ c2 = input.slice(128, -64);
+ c3 = input.slice(-64);
+ }
+ c2 = Uint8Array.from(fromHex(c2));
+ const c1 = this.ecParams.curve.decodePointHex("04" + c1X + c1Y);
+
+ /*
+ * Compute the p2 (secret) value by taking the C1 point provided in the encrypted package, and multiplying by the private k value
+ */
+ const p2 = c1.multiply(this.privateKey);
+
+ /*
+ * Similar to encryption; compute sufficient length key material and XOR the input data to recover the original message
+ */
+ const key = this.kdf(p2, c2.byteLength);
+
+ for (let i = 0; i < c2.byteLength; i++) {
+ c2[i] ^= Utils.ord(key[i]);
+ }
+
+ const check = this.c3(p2, c2);
+ if (check === c3) {
+ return c2.buffer;
+ } else {
+ throw new OperationError("Decryption Error -- Computed Hashes Do Not Match");
+ }
+ }
+
+
+ /**
+ * Generates a large random number
+ *
+ * @param {*} limit
+ * @returns
+ */
+ getBigRandom(limit) {
+ return new r.BigInteger(limit.bitLength(), this.rng)
+ .mod(limit.subtract(r.BigInteger.ONE))
+ .add(r.BigInteger.ONE);
+ }
+
+ /**
+ * Helper function for generating a large random K number; utilized for generating our initial C1 point
+ * TODO: Do we need to do any sort of validation on the resulting k values?
+ *
+ * @returns {BigInteger}
+ */
+ generatePublicKey() {
+ const n = this.ecParams.n;
+ const k = this.getBigRandom(n);
+ return k;
+ }
+
+ /**
+ * SM2 Key Derivation Function (KDF); Takes P2 point, and generates a key material stream large enough to encrypt all of the input data
+ *
+ * @param {*} p2
+ * @param {*} len
+ * @returns {string}
+ */
+ kdf(p2, len) {
+ const [hX, hY] = this.getPointAsHex(p2);
+
+ const total = Math.ceil(len / 32) + 1;
+ let cnt = 1;
+
+ let keyMaterial = "";
+
+ while (cnt < total) {
+ const num = Utils.intToByteArray(cnt, 4, "big");
+ const overall = fromHex(hX).concat(fromHex(hY)).concat(num);
+ keyMaterial += this.sm3(overall);
+ cnt++;
+ }
+ return keyMaterial;
+ }
+
+ /**
+ * Calculates the C3 component of our final encrypted payload; which is the SM3 hash of the P2 point and the original, unencrypted input data
+ *
+ * @param {*} p2
+ * @param {*} input
+ * @returns {string}
+ */
+ c3(p2, input) {
+ const [hX, hY] = this.getPointAsHex(p2);
+
+ const overall = fromHex(hX).concat(Array.from(input)).concat(fromHex(hY));
+
+ return toHex(this.sm3(overall));
+
+ }
+
+ /**
+ * SM3 setup helper function; takes input data as an array, processes the hash and returns the result
+ *
+ * @param {*} data
+ * @returns {string}
+ */
+ sm3(data) {
+ const hashData = Utils.arrayBufferToStr(Uint8Array.from(data).buffer, false);
+ const hasher = new Sm3();
+ hasher.update(hashData);
+ return hasher.finalize();
+ }
+
+ /**
+ * Utility function, returns an elliptic curve points X and Y values as hex;
+ *
+ * @param {EcPointFp} point
+ * @returns {[]}
+ */
+ getPointAsHex(point) {
+ const biX = point.getX().toBigInteger();
+ const biY = point.getY().toBigInteger();
+
+ const charlen = this.ecParams.keycharlen;
+ const hX = ("0000000000" + biX.toString(16)).slice(- charlen);
+ const hY = ("0000000000" + biY.toString(16)).slice(- charlen);
+ return [hX, hY];
+ }
+}
diff --git a/src/core/lib/Salsa20.mjs b/src/core/lib/Salsa20.mjs
new file mode 100644
index 00000000..d72831bf
--- /dev/null
+++ b/src/core/lib/Salsa20.mjs
@@ -0,0 +1,144 @@
+/**
+ * @author joostrijneveld [joost@joostrijneveld.nl]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Utils from "../Utils.mjs";
+
+/**
+ * Computes the Salsa20 permute function
+ *
+ * @param {byteArray} x
+ * @param {integer} rounds
+ */
+function salsa20Permute(x, rounds) {
+ /**
+ * Macro to compute a 32-bit rotate-left operation
+ *
+ * @param {integer} x
+ * @param {integer} n
+ * @returns {integer}
+ */
+ function ROL32(x, n) {
+ return ((x << n) & 0xFFFFFFFF) | (x >>> (32 - n));
+ }
+
+ /**
+ * Macro to compute a single Salsa20 quarterround operation
+ *
+ * @param {integer} x
+ * @param {integer} a
+ * @param {integer} b
+ * @param {integer} c
+ * @param {integer} d
+ * @returns {integer}
+ */
+ function quarterround(x, a, b, c, d) {
+ x[b] ^= ROL32((x[a] + x[d]) & 0xFFFFFFFF, 7);
+ x[c] ^= ROL32((x[b] + x[a]) & 0xFFFFFFFF, 9);
+ x[d] ^= ROL32((x[c] + x[b]) & 0xFFFFFFFF, 13);
+ x[a] ^= ROL32((x[d] + x[c]) & 0xFFFFFFFF, 18);
+ }
+
+ for (let i = 0; i < rounds / 2; i++) {
+ quarterround(x, 0, 4, 8, 12);
+ quarterround(x, 5, 9, 13, 1);
+ quarterround(x, 10, 14, 2, 6);
+ quarterround(x, 15, 3, 7, 11);
+ quarterround(x, 0, 1, 2, 3);
+ quarterround(x, 5, 6, 7, 4);
+ quarterround(x, 10, 11, 8, 9);
+ quarterround(x, 15, 12, 13, 14);
+ }
+}
+
+/**
+ * Computes the Salsa20 block function
+ *
+ * @param {byteArray} key
+ * @param {byteArray} nonce
+ * @param {byteArray} counter
+ * @param {integer} rounds
+ * @returns {byteArray}
+ */
+export function salsa20Block(key, nonce, counter, rounds) {
+ const tau = "expand 16-byte k";
+ const sigma = "expand 32-byte k";
+ let state, c;
+ if (key.length === 16) {
+ c = Utils.strToByteArray(tau);
+ key = key.concat(key);
+ } else {
+ c = Utils.strToByteArray(sigma);
+ }
+
+ state = c.slice(0, 4);
+ state = state.concat(key.slice(0, 16));
+ state = state.concat(c.slice(4, 8));
+ state = state.concat(nonce);
+ state = state.concat(counter);
+ state = state.concat(c.slice(8, 12));
+ state = state.concat(key.slice(16, 32));
+ state = state.concat(c.slice(12, 16));
+
+ const x = Array();
+ for (let i = 0; i < 64; i += 4) {
+ x.push(Utils.byteArrayToInt(state.slice(i, i + 4), "little"));
+ }
+ const a = [...x];
+
+ salsa20Permute(x, rounds);
+
+ for (let i = 0; i < 16; i++) {
+ x[i] = (x[i] + a[i]) & 0xFFFFFFFF;
+ }
+
+ let output = Array();
+ for (let i = 0; i < 16; i++) {
+ output = output.concat(Utils.intToByteArray(x[i], 4, "little"));
+ }
+ return output;
+}
+
+/**
+ * Computes the hSalsa20 function
+ *
+ * @param {byteArray} key
+ * @param {byteArray} nonce
+ * @param {integer} rounds
+ * @returns {byteArray}
+ */
+export function hsalsa20(key, nonce, rounds) {
+ const tau = "expand 16-byte k";
+ const sigma = "expand 32-byte k";
+ let state, c;
+ if (key.length === 16) {
+ c = Utils.strToByteArray(tau);
+ key = key.concat(key);
+ } else {
+ c = Utils.strToByteArray(sigma);
+ }
+
+ state = c.slice(0, 4);
+ state = state.concat(key.slice(0, 16));
+ state = state.concat(c.slice(4, 8));
+ state = state.concat(nonce);
+ state = state.concat(c.slice(8, 12));
+ state = state.concat(key.slice(16, 32));
+ state = state.concat(c.slice(12, 16));
+
+ const x = Array();
+ for (let i = 0; i < 64; i += 4) {
+ x.push(Utils.byteArrayToInt(state.slice(i, i + 4), "little"));
+ }
+
+ salsa20Permute(x, rounds);
+
+ let output = Array();
+ const idx = [0, 5, 10, 15, 6, 7, 8, 9];
+ for (let i = 0; i < 8; i++) {
+ output = output.concat(Utils.intToByteArray(x[idx[i]], 4, "little"));
+ }
+ return output;
+}
diff --git a/src/core/lib/Sort.mjs b/src/core/lib/Sort.mjs
index 46bbebd9..c8998f61 100644
--- a/src/core/lib/Sort.mjs
+++ b/src/core/lib/Sort.mjs
@@ -103,3 +103,15 @@ export function hexadecimalSort(a, b) {
return a.localeCompare(b);
}
+
+/**
+ * Comparison operation for sorting by length
+ *
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+export function lengthSort(a, b) {
+ return a.length - b.length;
+}
+
diff --git a/src/core/lib/Stream.mjs b/src/core/lib/Stream.mjs
index 18ce71c3..8253c4cf 100644
--- a/src/core/lib/Stream.mjs
+++ b/src/core/lib/Stream.mjs
@@ -18,12 +18,23 @@ export default class Stream {
* Stream constructor.
*
* @param {Uint8Array} input
+ * @param {number} pos
+ * @param {number} bitPos
*/
- constructor(input) {
+ constructor(input, pos=0, bitPos=0) {
this.bytes = input;
this.length = this.bytes.length;
- this.position = 0;
- this.bitPos = 0;
+ this.position = pos;
+ this.bitPos = bitPos;
+ }
+
+ /**
+ * Clone this Stream returning a new identical Stream.
+ *
+ * @returns {Stream}
+ */
+ clone() {
+ return new Stream(this.bytes, this.position, this.bitPos);
}
/**
diff --git a/src/core/lib/TLS.mjs b/src/core/lib/TLS.mjs
new file mode 100644
index 00000000..eaf661a8
--- /dev/null
+++ b/src/core/lib/TLS.mjs
@@ -0,0 +1,877 @@
+/**
+ * TLS resources.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import OperationError from "../errors/OperationError.mjs";
+import Stream from "../lib/Stream.mjs";
+
+/**
+ * Parse a TLS Record
+ * @param {Uint8Array} bytes
+ * @returns {JSON}
+ */
+export function parseTLSRecord(bytes) {
+ const s = new Stream(bytes);
+ const b = s.clone();
+ const r = {};
+
+ // Content type
+ r.contentType = {
+ description: "Content Type",
+ length: 1,
+ data: b.getBytes(1),
+ value: s.readInt(1)
+ };
+ if (r.contentType.value !== 0x16)
+ throw new OperationError("Not handshake data.");
+
+ // Version
+ r.version = {
+ description: "Protocol Version",
+ length: 2,
+ data: b.getBytes(2),
+ value: s.readInt(2)
+ };
+
+ // Length
+ r.length = {
+ description: "Record Length",
+ length: 2,
+ data: b.getBytes(2),
+ value: s.readInt(2)
+ };
+ if (s.length !== r.length.value + 5)
+ throw new OperationError("Incorrect handshake length.");
+
+ // Handshake
+ r.handshake = {
+ description: "Handshake",
+ length: r.length.value,
+ data: b.getBytes(r.length.value),
+ value: parseHandshake(s.getBytes(r.length.value))
+ };
+
+ return r;
+}
+
+/**
+ * Parse a TLS Handshake
+ * @param {Uint8Array} bytes
+ * @returns {JSON}
+ */
+function parseHandshake(bytes) {
+ const s = new Stream(bytes);
+ const b = s.clone();
+ const h = {};
+
+ // Handshake type
+ h.handshakeType = {
+ description: "Handshake Type",
+ length: 1,
+ data: b.getBytes(1),
+ value: s.readInt(1)
+ };
+
+ // Handshake length
+ h.handshakeLength = {
+ description: "Handshake Length",
+ length: 3,
+ data: b.getBytes(3),
+ value: s.readInt(3)
+ };
+ if (s.length !== h.handshakeLength.value + 4)
+ throw new OperationError("Not enough data in Handshake message.");
+
+
+ switch (h.handshakeType.value) {
+ case 0x01:
+ h.handshakeType.description = "Client Hello";
+ parseClientHello(s, b, h);
+ break;
+ case 0x02:
+ h.handshakeType.description = "Server Hello";
+ parseServerHello(s, b, h);
+ break;
+ default:
+ throw new OperationError("Not a known handshake message.");
+ }
+
+ return h;
+}
+
+/**
+ * Parse a TLS Client Hello
+ * @param {Stream} s
+ * @param {Stream} b
+ * @param {Object} h
+ * @returns {JSON}
+ */
+function parseClientHello(s, b, h) {
+ // Hello version
+ h.helloVersion = {
+ description: "Client Hello Version",
+ length: 2,
+ data: b.getBytes(2),
+ value: s.readInt(2)
+ };
+
+ // Random
+ h.random = {
+ description: "Client Random",
+ length: 32,
+ data: b.getBytes(32),
+ value: s.getBytes(32)
+ };
+
+ // Session ID Length
+ h.sessionIDLength = {
+ description: "Session ID Length",
+ length: 1,
+ data: b.getBytes(1),
+ value: s.readInt(1)
+ };
+
+ // Session ID
+ h.sessionID = {
+ description: "Session ID",
+ length: h.sessionIDLength.value,
+ data: b.getBytes(h.sessionIDLength.value),
+ value: s.getBytes(h.sessionIDLength.value)
+ };
+
+ // Cipher Suites Length
+ h.cipherSuitesLength = {
+ description: "Cipher Suites Length",
+ length: 2,
+ data: b.getBytes(2),
+ value: s.readInt(2)
+ };
+
+ // Cipher Suites
+ h.cipherSuites = {
+ description: "Cipher Suites",
+ length: h.cipherSuitesLength.value,
+ data: b.getBytes(h.cipherSuitesLength.value),
+ value: parseCipherSuites(s.getBytes(h.cipherSuitesLength.value))
+ };
+
+ // Compression Methods Length
+ h.compressionMethodsLength = {
+ description: "Compression Methods Length",
+ length: 1,
+ data: b.getBytes(1),
+ value: s.readInt(1)
+ };
+
+ // Compression Methods
+ h.compressionMethods = {
+ description: "Compression Methods",
+ length: h.compressionMethodsLength.value,
+ data: b.getBytes(h.compressionMethodsLength.value),
+ value: parseCompressionMethods(s.getBytes(h.compressionMethodsLength.value))
+ };
+
+ // Extensions Length
+ h.extensionsLength = {
+ description: "Extensions Length",
+ length: 2,
+ data: b.getBytes(2),
+ value: s.readInt(2)
+ };
+
+ // Extensions
+ h.extensions = {
+ description: "Extensions",
+ length: h.extensionsLength.value,
+ data: b.getBytes(h.extensionsLength.value),
+ value: parseExtensions(s.getBytes(h.extensionsLength.value))
+ };
+
+ return h;
+}
+
+/**
+ * Parse a TLS Server Hello
+ * @param {Stream} s
+ * @param {Stream} b
+ * @param {Object} h
+ * @returns {JSON}
+ */
+function parseServerHello(s, b, h) {
+ // Hello version
+ h.helloVersion = {
+ description: "Server Hello Version",
+ length: 2,
+ data: b.getBytes(2),
+ value: s.readInt(2)
+ };
+
+ // Random
+ h.random = {
+ description: "Server Random",
+ length: 32,
+ data: b.getBytes(32),
+ value: s.getBytes(32)
+ };
+
+ // Session ID Length
+ h.sessionIDLength = {
+ description: "Session ID Length",
+ length: 1,
+ data: b.getBytes(1),
+ value: s.readInt(1)
+ };
+
+ // Session ID
+ h.sessionID = {
+ description: "Session ID",
+ length: h.sessionIDLength.value,
+ data: b.getBytes(h.sessionIDLength.value),
+ value: s.getBytes(h.sessionIDLength.value)
+ };
+
+ // Cipher Suite
+ h.cipherSuite = {
+ description: "Selected Cipher Suite",
+ length: 2,
+ data: b.getBytes(2),
+ value: CIPHER_SUITES_LOOKUP[s.readInt(2)] || "Unknown"
+ };
+
+ // Compression Method
+ h.compressionMethod = {
+ description: "Selected Compression Method",
+ length: 1,
+ data: b.getBytes(1),
+ value: s.readInt(1) // TODO: Compression method name here
+ };
+
+ // Extensions Length
+ h.extensionsLength = {
+ description: "Extensions Length",
+ length: 2,
+ data: b.getBytes(2),
+ value: s.readInt(2)
+ };
+
+ // Extensions
+ h.extensions = {
+ description: "Extensions",
+ length: h.extensionsLength.value,
+ data: b.getBytes(h.extensionsLength.value),
+ value: parseExtensions(s.getBytes(h.extensionsLength.value))
+ };
+}
+
+/**
+ * Parse Cipher Suites
+ * @param {Uint8Array} bytes
+ * @returns {JSON}
+ */
+function parseCipherSuites(bytes) {
+ const s = new Stream(bytes);
+ const b = s.clone();
+ const cs = [];
+
+ while (s.hasMore()) {
+ cs.push({
+ description: "Cipher Suite",
+ length: 2,
+ data: b.getBytes(2),
+ value: CIPHER_SUITES_LOOKUP[s.readInt(2)] || "Unknown"
+ });
+ }
+ return cs;
+}
+
+/**
+ * Parse Compression Methods
+ * @param {Uint8Array} bytes
+ * @returns {JSON}
+ */
+function parseCompressionMethods(bytes) {
+ const s = new Stream(bytes);
+ const b = s.clone();
+ const cm = [];
+
+ while (s.hasMore()) {
+ cm.push({
+ description: "Compression Method",
+ length: 1,
+ data: b.getBytes(1),
+ value: s.readInt(1) // TODO: Compression method name here
+ });
+ }
+ return cm;
+}
+
+/**
+ * Parse Extensions
+ * @param {Uint8Array} bytes
+ * @returns {JSON}
+ */
+function parseExtensions(bytes) {
+ const s = new Stream(bytes);
+ const b = s.clone();
+
+ const exts = [];
+ while (s.hasMore()) {
+ const ext = {};
+
+ // Type
+ ext.type = {
+ description: "Extension Type",
+ length: 2,
+ data: b.getBytes(2),
+ value: EXTENSION_LOOKUP[s.readInt(2)] || "unknown"
+ };
+
+ // Length
+ ext.length = {
+ description: "Extension Length",
+ length: 2,
+ data: b.getBytes(2),
+ value: s.readInt(2)
+ };
+
+ // Value
+ ext.value = {
+ description: "Extension Value",
+ length: ext.length.value,
+ data: b.getBytes(ext.length.value),
+ value: s.getBytes(ext.length.value)
+ };
+
+ exts.push(ext);
+ }
+
+ return exts;
+}
+
+/**
+ * Extension type lookup table
+ */
+const EXTENSION_LOOKUP = {
+ 0: "server_name",
+ 1: "max_fragment_length",
+ 2: "client_certificate_url",
+ 3: "trusted_ca_keys",
+ 4: "truncated_hmac",
+ 5: "status_request",
+ 6: "user_mapping",
+ 7: "client_authz",
+ 8: "server_authz",
+ 9: "cert_type",
+ 10: "supported_groups",
+ 11: "ec_point_formats",
+ 12: "srp",
+ 13: "signature_algorithms",
+ 14: "use_srtp",
+ 15: "heartbeat",
+ 16: "application_layer_protocol_negotiation",
+ 17: "status_request_v2",
+ 18: "signed_certificate_timestamp",
+ 19: "client_certificate_type",
+ 20: "server_certificate_type",
+ 21: "padding",
+ 22: "encrypt_then_mac",
+ 23: "extended_master_secret",
+ 24: "token_binding",
+ 25: "cached_info",
+ 26: "tls_lts",
+ 27: "compress_certificate",
+ 28: "record_size_limit",
+ 29: "pwd_protect",
+ 30: "pwd_clear",
+ 31: "password_salt",
+ 32: "ticket_pinning",
+ 33: "tls_cert_with_extern_psk",
+ 34: "delegated_credential",
+ 35: "session_ticket",
+ 36: "TLMSP",
+ 37: "TLMSP_proxying",
+ 38: "TLMSP_delegate",
+ 39: "supported_ekt_ciphers",
+ 40: "Reserved",
+ 41: "pre_shared_key",
+ 42: "early_data",
+ 43: "supported_versions",
+ 44: "cookie",
+ 45: "psk_key_exchange_modes",
+ 46: "Reserved",
+ 47: "certificate_authorities",
+ 48: "oid_filters",
+ 49: "post_handshake_auth",
+ 50: "signature_algorithms_cert",
+ 51: "key_share",
+ 52: "transparency_info",
+ 53: "connection_id (deprecated)",
+ 54: "connection_id",
+ 55: "external_id_hash",
+ 56: "external_session_id",
+ 57: "quic_transport_parameters",
+ 58: "ticket_request",
+ 59: "dnssec_chain",
+ 60: "sequence_number_encryption_algorithms",
+ 61: "rrc",
+ 2570: "GREASE",
+ 6682: "GREASE",
+ 10794: "GREASE",
+ 14906: "GREASE",
+ 17513: "application_settings",
+ 19018: "GREASE",
+ 23130: "GREASE",
+ 27242: "GREASE",
+ 31354: "GREASE",
+ 35466: "GREASE",
+ 39578: "GREASE",
+ 43690: "GREASE",
+ 47802: "GREASE",
+ 51914: "GREASE",
+ 56026: "GREASE",
+ 60138: "GREASE",
+ 64250: "GREASE",
+ 64768: "ech_outer_extensions",
+ 65037: "encrypted_client_hello",
+ 65281: "renegotiation_info"
+};
+
+/**
+ * Cipher suites lookup table
+ */
+const CIPHER_SUITES_LOOKUP = {
+ 0x0000: "TLS_NULL_WITH_NULL_NULL",
+ 0x0001: "TLS_RSA_WITH_NULL_MD5",
+ 0x0002: "TLS_RSA_WITH_NULL_SHA",
+ 0x0003: "TLS_RSA_EXPORT_WITH_RC4_40_MD5",
+ 0x0004: "TLS_RSA_WITH_RC4_128_MD5",
+ 0x0005: "TLS_RSA_WITH_RC4_128_SHA",
+ 0x0006: "TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5",
+ 0x0007: "TLS_RSA_WITH_IDEA_CBC_SHA",
+ 0x0008: "TLS_RSA_EXPORT_WITH_DES40_CBC_SHA",
+ 0x0009: "TLS_RSA_WITH_DES_CBC_SHA",
+ 0x000A: "TLS_RSA_WITH_3DES_EDE_CBC_SHA",
+ 0x000B: "TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA",
+ 0x000C: "TLS_DH_DSS_WITH_DES_CBC_SHA",
+ 0x000D: "TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA",
+ 0x000E: "TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA",
+ 0x000F: "TLS_DH_RSA_WITH_DES_CBC_SHA",
+ 0x0010: "TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA",
+ 0x0011: "TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA",
+ 0x0012: "TLS_DHE_DSS_WITH_DES_CBC_SHA",
+ 0x0013: "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA",
+ 0x0014: "TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA",
+ 0x0015: "TLS_DHE_RSA_WITH_DES_CBC_SHA",
+ 0x0016: "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA",
+ 0x0017: "TLS_DH_anon_EXPORT_WITH_RC4_40_MD5",
+ 0x0018: "TLS_DH_anon_WITH_RC4_128_MD5",
+ 0x0019: "TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA",
+ 0x001A: "TLS_DH_anon_WITH_DES_CBC_SHA",
+ 0x001B: "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA",
+ 0x001E: "TLS_KRB5_WITH_DES_CBC_SHA",
+ 0x001F: "TLS_KRB5_WITH_3DES_EDE_CBC_SHA",
+ 0x0020: "TLS_KRB5_WITH_RC4_128_SHA",
+ 0x0021: "TLS_KRB5_WITH_IDEA_CBC_SHA",
+ 0x0022: "TLS_KRB5_WITH_DES_CBC_MD5",
+ 0x0023: "TLS_KRB5_WITH_3DES_EDE_CBC_MD5",
+ 0x0024: "TLS_KRB5_WITH_RC4_128_MD5",
+ 0x0025: "TLS_KRB5_WITH_IDEA_CBC_MD5",
+ 0x0026: "TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA",
+ 0x0027: "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA",
+ 0x0028: "TLS_KRB5_EXPORT_WITH_RC4_40_SHA",
+ 0x0029: "TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5",
+ 0x002A: "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5",
+ 0x002B: "TLS_KRB5_EXPORT_WITH_RC4_40_MD5",
+ 0x002C: "TLS_PSK_WITH_NULL_SHA",
+ 0x002D: "TLS_DHE_PSK_WITH_NULL_SHA",
+ 0x002E: "TLS_RSA_PSK_WITH_NULL_SHA",
+ 0x002F: "TLS_RSA_WITH_AES_128_CBC_SHA",
+ 0x0030: "TLS_DH_DSS_WITH_AES_128_CBC_SHA",
+ 0x0031: "TLS_DH_RSA_WITH_AES_128_CBC_SHA",
+ 0x0032: "TLS_DHE_DSS_WITH_AES_128_CBC_SHA",
+ 0x0033: "TLS_DHE_RSA_WITH_AES_128_CBC_SHA",
+ 0x0034: "TLS_DH_anon_WITH_AES_128_CBC_SHA",
+ 0x0035: "TLS_RSA_WITH_AES_256_CBC_SHA",
+ 0x0036: "TLS_DH_DSS_WITH_AES_256_CBC_SHA",
+ 0x0037: "TLS_DH_RSA_WITH_AES_256_CBC_SHA",
+ 0x0038: "TLS_DHE_DSS_WITH_AES_256_CBC_SHA",
+ 0x0039: "TLS_DHE_RSA_WITH_AES_256_CBC_SHA",
+ 0x003A: "TLS_DH_anon_WITH_AES_256_CBC_SHA",
+ 0x003B: "TLS_RSA_WITH_NULL_SHA256",
+ 0x003C: "TLS_RSA_WITH_AES_128_CBC_SHA256",
+ 0x003D: "TLS_RSA_WITH_AES_256_CBC_SHA256",
+ 0x003E: "TLS_DH_DSS_WITH_AES_128_CBC_SHA256",
+ 0x003F: "TLS_DH_RSA_WITH_AES_128_CBC_SHA256",
+ 0x0040: "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256",
+ 0x0041: "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA",
+ 0x0042: "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA",
+ 0x0043: "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA",
+ 0x0044: "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA",
+ 0x0045: "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA",
+ 0x0046: "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA",
+ 0x0067: "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256",
+ 0x0068: "TLS_DH_DSS_WITH_AES_256_CBC_SHA256",
+ 0x0069: "TLS_DH_RSA_WITH_AES_256_CBC_SHA256",
+ 0x006A: "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256",
+ 0x006B: "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256",
+ 0x006C: "TLS_DH_anon_WITH_AES_128_CBC_SHA256",
+ 0x006D: "TLS_DH_anon_WITH_AES_256_CBC_SHA256",
+ 0x0084: "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA",
+ 0x0085: "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA",
+ 0x0086: "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA",
+ 0x0087: "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA",
+ 0x0088: "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA",
+ 0x0089: "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA",
+ 0x008A: "TLS_PSK_WITH_RC4_128_SHA",
+ 0x008B: "TLS_PSK_WITH_3DES_EDE_CBC_SHA",
+ 0x008C: "TLS_PSK_WITH_AES_128_CBC_SHA",
+ 0x008D: "TLS_PSK_WITH_AES_256_CBC_SHA",
+ 0x008E: "TLS_DHE_PSK_WITH_RC4_128_SHA",
+ 0x008F: "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA",
+ 0x0090: "TLS_DHE_PSK_WITH_AES_128_CBC_SHA",
+ 0x0091: "TLS_DHE_PSK_WITH_AES_256_CBC_SHA",
+ 0x0092: "TLS_RSA_PSK_WITH_RC4_128_SHA",
+ 0x0093: "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA",
+ 0x0094: "TLS_RSA_PSK_WITH_AES_128_CBC_SHA",
+ 0x0095: "TLS_RSA_PSK_WITH_AES_256_CBC_SHA",
+ 0x0096: "TLS_RSA_WITH_SEED_CBC_SHA",
+ 0x0097: "TLS_DH_DSS_WITH_SEED_CBC_SHA",
+ 0x0098: "TLS_DH_RSA_WITH_SEED_CBC_SHA",
+ 0x0099: "TLS_DHE_DSS_WITH_SEED_CBC_SHA",
+ 0x009A: "TLS_DHE_RSA_WITH_SEED_CBC_SHA",
+ 0x009B: "TLS_DH_anon_WITH_SEED_CBC_SHA",
+ 0x009C: "TLS_RSA_WITH_AES_128_GCM_SHA256",
+ 0x009D: "TLS_RSA_WITH_AES_256_GCM_SHA384",
+ 0x009E: "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256",
+ 0x009F: "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384",
+ 0x00A0: "TLS_DH_RSA_WITH_AES_128_GCM_SHA256",
+ 0x00A1: "TLS_DH_RSA_WITH_AES_256_GCM_SHA384",
+ 0x00A2: "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256",
+ 0x00A3: "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384",
+ 0x00A4: "TLS_DH_DSS_WITH_AES_128_GCM_SHA256",
+ 0x00A5: "TLS_DH_DSS_WITH_AES_256_GCM_SHA384",
+ 0x00A6: "TLS_DH_anon_WITH_AES_128_GCM_SHA256",
+ 0x00A7: "TLS_DH_anon_WITH_AES_256_GCM_SHA384",
+ 0x00A8: "TLS_PSK_WITH_AES_128_GCM_SHA256",
+ 0x00A9: "TLS_PSK_WITH_AES_256_GCM_SHA384",
+ 0x00AA: "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256",
+ 0x00AB: "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384",
+ 0x00AC: "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256",
+ 0x00AD: "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384",
+ 0x00AE: "TLS_PSK_WITH_AES_128_CBC_SHA256",
+ 0x00AF: "TLS_PSK_WITH_AES_256_CBC_SHA384",
+ 0x00B0: "TLS_PSK_WITH_NULL_SHA256",
+ 0x00B1: "TLS_PSK_WITH_NULL_SHA384",
+ 0x00B2: "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256",
+ 0x00B3: "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384",
+ 0x00B4: "TLS_DHE_PSK_WITH_NULL_SHA256",
+ 0x00B5: "TLS_DHE_PSK_WITH_NULL_SHA384",
+ 0x00B6: "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256",
+ 0x00B7: "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384",
+ 0x00B8: "TLS_RSA_PSK_WITH_NULL_SHA256",
+ 0x00B9: "TLS_RSA_PSK_WITH_NULL_SHA384",
+ 0x00BA: "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256",
+ 0x00BB: "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256",
+ 0x00BC: "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256",
+ 0x00BD: "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256",
+ 0x00BE: "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256",
+ 0x00BF: "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256",
+ 0x00C0: "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256",
+ 0x00C1: "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256",
+ 0x00C2: "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256",
+ 0x00C3: "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256",
+ 0x00C4: "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256",
+ 0x00C5: "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256",
+ 0x00C6: "TLS_SM4_GCM_SM3",
+ 0x00C7: "TLS_SM4_CCM_SM3",
+ 0x00FF: "TLS_EMPTY_RENEGOTIATION_INFO_SCSV",
+ 0x0A0A: "GREASE",
+ 0x1301: "TLS_AES_128_GCM_SHA256",
+ 0x1302: "TLS_AES_256_GCM_SHA384",
+ 0x1303: "TLS_CHACHA20_POLY1305_SHA256",
+ 0x1304: "TLS_AES_128_CCM_SHA256",
+ 0x1305: "TLS_AES_128_CCM_8_SHA256",
+ 0x1306: "TLS_AEGIS_256_SHA512",
+ 0x1307: "TLS_AEGIS_128L_SHA256",
+ 0x1A1A: "GREASE",
+ 0x2A2A: "GREASE",
+ 0x3A3A: "GREASE",
+ 0x4A4A: "GREASE",
+ 0x5600: "TLS_FALLBACK_SCSV",
+ 0x5A5A: "GREASE",
+ 0x6A6A: "GREASE",
+ 0x7A7A: "GREASE",
+ 0x8A8A: "GREASE",
+ 0x9A9A: "GREASE",
+ 0xAAAA: "GREASE",
+ 0xBABA: "GREASE",
+ 0xC001: "TLS_ECDH_ECDSA_WITH_NULL_SHA",
+ 0xC002: "TLS_ECDH_ECDSA_WITH_RC4_128_SHA",
+ 0xC003: "TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA",
+ 0xC004: "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA",
+ 0xC005: "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA",
+ 0xC006: "TLS_ECDHE_ECDSA_WITH_NULL_SHA",
+ 0xC007: "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA",
+ 0xC008: "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA",
+ 0xC009: "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
+ 0xC00A: "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA",
+ 0xC00B: "TLS_ECDH_RSA_WITH_NULL_SHA",
+ 0xC00C: "TLS_ECDH_RSA_WITH_RC4_128_SHA",
+ 0xC00D: "TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA",
+ 0xC00E: "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA",
+ 0xC00F: "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA",
+ 0xC010: "TLS_ECDHE_RSA_WITH_NULL_SHA",
+ 0xC011: "TLS_ECDHE_RSA_WITH_RC4_128_SHA",
+ 0xC012: "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA",
+ 0xC013: "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA",
+ 0xC014: "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA",
+ 0xC015: "TLS_ECDH_anon_WITH_NULL_SHA",
+ 0xC016: "TLS_ECDH_anon_WITH_RC4_128_SHA",
+ 0xC017: "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA",
+ 0xC018: "TLS_ECDH_anon_WITH_AES_128_CBC_SHA",
+ 0xC019: "TLS_ECDH_anon_WITH_AES_256_CBC_SHA",
+ 0xC01A: "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA",
+ 0xC01B: "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA",
+ 0xC01C: "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA",
+ 0xC01D: "TLS_SRP_SHA_WITH_AES_128_CBC_SHA",
+ 0xC01E: "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA",
+ 0xC01F: "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA",
+ 0xC020: "TLS_SRP_SHA_WITH_AES_256_CBC_SHA",
+ 0xC021: "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA",
+ 0xC022: "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA",
+ 0xC023: "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
+ 0xC024: "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
+ 0xC025: "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256",
+ 0xC026: "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384",
+ 0xC027: "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
+ 0xC028: "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384",
+ 0xC029: "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256",
+ 0xC02A: "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384",
+ 0xC02B: "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+ 0xC02C: "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
+ 0xC02D: "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256",
+ 0xC02E: "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384",
+ 0xC02F: "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+ 0xC030: "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
+ 0xC031: "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256",
+ 0xC032: "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384",
+ 0xC033: "TLS_ECDHE_PSK_WITH_RC4_128_SHA",
+ 0xC034: "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA",
+ 0xC035: "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA",
+ 0xC036: "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA",
+ 0xC037: "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256",
+ 0xC038: "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384",
+ 0xC039: "TLS_ECDHE_PSK_WITH_NULL_SHA",
+ 0xC03A: "TLS_ECDHE_PSK_WITH_NULL_SHA256",
+ 0xC03B: "TLS_ECDHE_PSK_WITH_NULL_SHA384",
+ 0xC03C: "TLS_RSA_WITH_ARIA_128_CBC_SHA256",
+ 0xC03D: "TLS_RSA_WITH_ARIA_256_CBC_SHA384",
+ 0xC03E: "TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256",
+ 0xC03F: "TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384",
+ 0xC040: "TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256",
+ 0xC041: "TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384",
+ 0xC042: "TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256",
+ 0xC043: "TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384",
+ 0xC044: "TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256",
+ 0xC045: "TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384",
+ 0xC046: "TLS_DH_anon_WITH_ARIA_128_CBC_SHA256",
+ 0xC047: "TLS_DH_anon_WITH_ARIA_256_CBC_SHA384",
+ 0xC048: "TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256",
+ 0xC049: "TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384",
+ 0xC04A: "TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256",
+ 0xC04B: "TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384",
+ 0xC04C: "TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256",
+ 0xC04D: "TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384",
+ 0xC04E: "TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256",
+ 0xC04F: "TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384",
+ 0xC050: "TLS_RSA_WITH_ARIA_128_GCM_SHA256",
+ 0xC051: "TLS_RSA_WITH_ARIA_256_GCM_SHA384",
+ 0xC052: "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256",
+ 0xC053: "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384",
+ 0xC054: "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256",
+ 0xC055: "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384",
+ 0xC056: "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256",
+ 0xC057: "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384",
+ 0xC058: "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256",
+ 0xC059: "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384",
+ 0xC05A: "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256",
+ 0xC05B: "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384",
+ 0xC05C: "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256",
+ 0xC05D: "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384",
+ 0xC05E: "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256",
+ 0xC05F: "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384",
+ 0xC060: "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256",
+ 0xC061: "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384",
+ 0xC062: "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256",
+ 0xC063: "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384",
+ 0xC064: "TLS_PSK_WITH_ARIA_128_CBC_SHA256",
+ 0xC065: "TLS_PSK_WITH_ARIA_256_CBC_SHA384",
+ 0xC066: "TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256",
+ 0xC067: "TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384",
+ 0xC068: "TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256",
+ 0xC069: "TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384",
+ 0xC06A: "TLS_PSK_WITH_ARIA_128_GCM_SHA256",
+ 0xC06B: "TLS_PSK_WITH_ARIA_256_GCM_SHA384",
+ 0xC06C: "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256",
+ 0xC06D: "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384",
+ 0xC06E: "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256",
+ 0xC06F: "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384",
+ 0xC070: "TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256",
+ 0xC071: "TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384",
+ 0xC072: "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256",
+ 0xC073: "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384",
+ 0xC074: "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256",
+ 0xC075: "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384",
+ 0xC076: "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256",
+ 0xC077: "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384",
+ 0xC078: "TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256",
+ 0xC079: "TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384",
+ 0xC07A: "TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256",
+ 0xC07B: "TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384",
+ 0xC07C: "TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256",
+ 0xC07D: "TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384",
+ 0xC07E: "TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256",
+ 0xC07F: "TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384",
+ 0xC080: "TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256",
+ 0xC081: "TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384",
+ 0xC082: "TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256",
+ 0xC083: "TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384",
+ 0xC084: "TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256",
+ 0xC085: "TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384",
+ 0xC086: "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256",
+ 0xC087: "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384",
+ 0xC088: "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256",
+ 0xC089: "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384",
+ 0xC08A: "TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256",
+ 0xC08B: "TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384",
+ 0xC08C: "TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256",
+ 0xC08D: "TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384",
+ 0xC08E: "TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256",
+ 0xC08F: "TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384",
+ 0xC090: "TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256",
+ 0xC091: "TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384",
+ 0xC092: "TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256",
+ 0xC093: "TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384",
+ 0xC094: "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256",
+ 0xC095: "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384",
+ 0xC096: "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256",
+ 0xC097: "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384",
+ 0xC098: "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256",
+ 0xC099: "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384",
+ 0xC09A: "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256",
+ 0xC09B: "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384",
+ 0xC09C: "TLS_RSA_WITH_AES_128_CCM",
+ 0xC09D: "TLS_RSA_WITH_AES_256_CCM",
+ 0xC09E: "TLS_DHE_RSA_WITH_AES_128_CCM",
+ 0xC09F: "TLS_DHE_RSA_WITH_AES_256_CCM",
+ 0xC0A0: "TLS_RSA_WITH_AES_128_CCM_8",
+ 0xC0A1: "TLS_RSA_WITH_AES_256_CCM_8",
+ 0xC0A2: "TLS_DHE_RSA_WITH_AES_128_CCM_8",
+ 0xC0A3: "TLS_DHE_RSA_WITH_AES_256_CCM_8",
+ 0xC0A4: "TLS_PSK_WITH_AES_128_CCM",
+ 0xC0A5: "TLS_PSK_WITH_AES_256_CCM",
+ 0xC0A6: "TLS_DHE_PSK_WITH_AES_128_CCM",
+ 0xC0A7: "TLS_DHE_PSK_WITH_AES_256_CCM",
+ 0xC0A8: "TLS_PSK_WITH_AES_128_CCM_8",
+ 0xC0A9: "TLS_PSK_WITH_AES_256_CCM_8",
+ 0xC0AA: "TLS_PSK_DHE_WITH_AES_128_CCM_8",
+ 0xC0AB: "TLS_PSK_DHE_WITH_AES_256_CCM_8",
+ 0xC0AC: "TLS_ECDHE_ECDSA_WITH_AES_128_CCM",
+ 0xC0AD: "TLS_ECDHE_ECDSA_WITH_AES_256_CCM",
+ 0xC0AE: "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8",
+ 0xC0AF: "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8",
+ 0xC0B0: "TLS_ECCPWD_WITH_AES_128_GCM_SHA256",
+ 0xC0B1: "TLS_ECCPWD_WITH_AES_256_GCM_SHA384",
+ 0xC0B2: "TLS_ECCPWD_WITH_AES_128_CCM_SHA256",
+ 0xC0B3: "TLS_ECCPWD_WITH_AES_256_CCM_SHA384",
+ 0xC0B4: "TLS_SHA256_SHA256",
+ 0xC0B5: "TLS_SHA384_SHA384",
+ 0xC100: "TLS_GOSTR341112_256_WITH_KUZNYECHIK_CTR_OMAC",
+ 0xC101: "TLS_GOSTR341112_256_WITH_MAGMA_CTR_OMAC",
+ 0xC102: "TLS_GOSTR341112_256_WITH_28147_CNT_IMIT",
+ 0xC103: "TLS_GOSTR341112_256_WITH_KUZNYECHIK_MGM_L",
+ 0xC104: "TLS_GOSTR341112_256_WITH_MAGMA_MGM_L",
+ 0xC105: "TLS_GOSTR341112_256_WITH_KUZNYECHIK_MGM_S",
+ 0xC106: "TLS_GOSTR341112_256_WITH_MAGMA_MGM_S",
+ 0xCACA: "GREASE",
+ 0xCCA8: "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256",
+ 0xCCA9: "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256",
+ 0xCCAA: "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256",
+ 0xCCAB: "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256",
+ 0xCCAC: "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256",
+ 0xCCAD: "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256",
+ 0xCCAE: "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256",
+ 0xD001: "TLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256",
+ 0xD002: "TLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384",
+ 0xD003: "TLS_ECDHE_PSK_WITH_AES_128_CCM_8_SHA256",
+ 0xD005: "TLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256",
+ 0xDADA: "GREASE",
+ 0xEAEA: "GREASE",
+ 0xFAFA: "GREASE",
+};
+
+/**
+ * GREASE values
+ */
+export const GREASE_VALUES = [
+ 0x0a0a,
+ 0x1a1a,
+ 0x2a2a,
+ 0x3a3a,
+ 0x4a4a,
+ 0x5a5a,
+ 0x6a6a,
+ 0x7a7a,
+ 0x8a8a,
+ 0x9a9a,
+ 0xaaaa,
+ 0xbaba,
+ 0xcaca,
+ 0xdada,
+ 0xeaea,
+ 0xfafa
+];
+
+/**
+ * Parses the supported_versions extension and returns the highest supported version.
+ * @param {Uint8Array} bytes
+ * @returns {number}
+ */
+export function parseHighestSupportedVersion(bytes) {
+ const s = new Stream(bytes);
+
+ // The Server Hello supported_versions extension simply contains the chosen version
+ if (s.length === 2) {
+ return s.readInt(2);
+ }
+
+ // Length
+ let i = s.readInt(1);
+
+ let highestVersion = 0;
+ while (s.hasMore() && i-- > 0) {
+ const v = s.readInt(2);
+ if (GREASE_VALUES.includes(v)) continue;
+ if (v > highestVersion) highestVersion = v;
+ }
+
+ return highestVersion;
+}
+
+/**
+ * Parses the application_layer_protocol_negotiation extension and returns the first value as raw bytes.
+ * @param {Uint8Array} bytes
+ * @returns {Uint8Array|null}
+ */
+export function parseFirstALPNValue(bytes) {
+ const s = new Stream(bytes);
+ const alpnExtLen = s.readInt(2);
+ if (alpnExtLen < 2) return null;
+ const strLen = s.readInt(1);
+ if (strLen < 1) return null;
+ return s.getBytes(strLen);
+}
diff --git a/src/core/lib/XXTEA.mjs b/src/core/lib/XXTEA.mjs
new file mode 100644
index 00000000..6d556fc5
--- /dev/null
+++ b/src/core/lib/XXTEA.mjs
@@ -0,0 +1,174 @@
+/**
+ * XXTEA library
+ *
+ * Encryption Algorithm Authors:
+ * David J. Wheeler
+ * Roger M. Needham
+ *
+ * @author Ma Bingyao [mabingyao@gmail.com]
+ * @author n1474335 [n1474335@gmail.com]
+ * @license MIT
+ */
+
+const DELTA = 0x9E3779B9;
+
+/**
+ * Convert a buffer to a Uint8Array
+ * @param {Uint32Array} v
+ * @param {boolean} includeLength
+ * @returns {Uint8Array}
+ */
+function toUint8Array(v, includeLength) {
+ const length = v.length;
+ let n = length << 2;
+ if (includeLength) {
+ const m = v[length - 1];
+ n -= 4;
+ if ((m < n - 3) || (m > n)) {
+ return null;
+ }
+ n = m;
+ }
+ const bytes = new Uint8Array(n);
+ for (let i = 0; i < n; i++) {
+ bytes[i] = v[i >> 2] >> ((i & 3) << 3);
+ }
+ return bytes;
+}
+
+/**
+ * Convert a buffer to a Uint32Array
+ * @param {TypedArray} bs
+ * @param {boolean} includeLength
+ * @returns {Uint32Array}
+ */
+function toUint32Array(bs, includeLength) {
+ const length = bs.length;
+ let n = length >> 2;
+ if ((length & 3) !== 0) {
+ ++n;
+ }
+ let v;
+ if (includeLength) {
+ v = new Uint32Array(n + 1);
+ v[n] = length;
+ } else {
+ v = new Uint32Array(n);
+ }
+ for (let i = 0; i < length; ++i) {
+ v[i >> 2] |= bs[i] << ((i & 3) << 3);
+ }
+ return v;
+}
+
+/**
+ * Mask an int to 32 bits
+ * @param {number} i
+ * @returns {number}
+ */
+function int32(i) {
+ return i & 0xFFFFFFFF;
+}
+
+/**
+ * MX function for data randomisation
+ * @param {number} sum
+ * @param {number} y
+ * @param {number} z
+ * @param {number} p
+ * @param {number} e
+ * @param {number} k
+ * @returns {number}
+ */
+function mx(sum, y, z, p, e, k) {
+ return ((z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4)) ^ ((sum ^ y) + (k[p & 3 ^ e] ^ z));
+}
+
+/**
+ * Ensure an array is a multiple of 16 bits
+ * @param {TypedArray} k
+ * @returns {TypedArray}
+ */
+function fixk(k) {
+ if (k.length < 16) {
+ const key = new Uint8Array(16);
+ key.set(k);
+ return key;
+ }
+ return k;
+}
+
+/**
+ * Performs XXTEA encryption on a Uint32Array
+ * @param {Uint32Array} v
+ * @param {Uint32Array} k
+ * @returns {Uint32Array}
+ */
+function encryptUint32Array(v, k) {
+ const length = v.length;
+ const n = length - 1;
+ let y, z, sum, e, p, q;
+ z = v[n];
+ sum = 0;
+ for (q = Math.floor(6 + 52 / length) | 0; q > 0; --q) {
+ sum = int32(sum + DELTA);
+ e = sum >>> 2 & 3;
+ for (p = 0; p < n; ++p) {
+ y = v[p + 1];
+ z = v[p] = int32(v[p] + mx(sum, y, z, p, e, k));
+ }
+ y = v[0];
+ z = v[n] = int32(v[n] + mx(sum, y, z, n, e, k));
+ }
+ return v;
+}
+
+/**
+ * Performs XXTEA decryption on a Uint32Array
+ * @param {Uint32Array} v
+ * @param {Uint32Array} k
+ * @returns {Uint32Array}
+ */
+function decryptUint32Array(v, k) {
+ const length = v.length;
+ const n = length - 1;
+ let y, z, sum, e, p;
+ y = v[0];
+ const q = Math.floor(6 + 52 / length);
+ for (sum = int32(q * DELTA); sum !== 0; sum = int32(sum - DELTA)) {
+ e = sum >>> 2 & 3;
+ for (p = n; p > 0; --p) {
+ z = v[p - 1];
+ y = v[p] = int32(v[p] - mx(sum, y, z, p, e, k));
+ }
+ z = v[n];
+ y = v[0] = int32(v[0] - mx(sum, y, z, 0, e, k));
+ }
+ return v;
+}
+
+/**
+ * Encrypt function
+ * @param {TypedArray} data
+ * @param {TypedArray} key
+ * @returns {Uint8Array}
+ */
+export function encrypt(data, key) {
+ if (data === undefined || data === null || data.length === 0) {
+ return data;
+ }
+ return toUint8Array(encryptUint32Array(toUint32Array(data, true), toUint32Array(fixk(key), false)), false);
+}
+
+/**
+ * Decrypt function
+ * @param {TypedArray} data
+ * @param {TypedArray} key
+ * @returns {Uint8Array}
+ */
+export function decrypt(data, key) {
+ if (data === undefined || data === null || data.length === 0) {
+ return data;
+ }
+ return toUint8Array(decryptUint32Array(toUint32Array(data, false), toUint32Array(fixk(key), false)), true);
+}
diff --git a/src/core/operations/A1Z26CipherDecode.mjs b/src/core/operations/A1Z26CipherDecode.mjs
index 0b097c2b..cc9aafbf 100644
--- a/src/core/operations/A1Z26CipherDecode.mjs
+++ b/src/core/operations/A1Z26CipherDecode.mjs
@@ -76,7 +76,7 @@ class A1Z26CipherDecode extends Operation {
const delim = Utils.charRep(args[0] || "Space");
if (input.length === 0) {
- return [];
+ return "";
}
const bites = input.split(delim);
diff --git a/src/core/operations/AESDecrypt.mjs b/src/core/operations/AESDecrypt.mjs
index e24a5119..5e6cec26 100644
--- a/src/core/operations/AESDecrypt.mjs
+++ b/src/core/operations/AESDecrypt.mjs
@@ -112,7 +112,7 @@ class AESDecrypt extends Operation {
run(input, args) {
const key = Utils.convertToByteString(args[0].string, args[0].option),
iv = Utils.convertToByteString(args[1].string, args[1].option),
- mode = args[2].substring(0, 3),
+ mode = args[2].split("/")[0],
noPadding = args[2].endsWith("NoPadding"),
inputType = args[3],
outputType = args[4],
diff --git a/src/core/operations/AESEncrypt.mjs b/src/core/operations/AESEncrypt.mjs
index 7b52ff03..84e1c540 100644
--- a/src/core/operations/AESEncrypt.mjs
+++ b/src/core/operations/AESEncrypt.mjs
@@ -66,6 +66,14 @@ class AESEncrypt extends Operation {
{
name: "ECB",
off: [5]
+ },
+ {
+ name: "CBC/NoPadding",
+ off: [5]
+ },
+ {
+ name: "ECB/NoPadding",
+ off: [5]
}
]
},
@@ -98,7 +106,8 @@ class AESEncrypt extends Operation {
run(input, args) {
const key = Utils.convertToByteString(args[0].string, args[0].option),
iv = Utils.convertToByteString(args[1].string, args[1].option),
- mode = args[2],
+ mode = args[2].split("/")[0],
+ noPadding = args[2].endsWith("NoPadding"),
inputType = args[3],
outputType = args[4],
aad = Utils.convertToByteString(args[5].string, args[5].option);
@@ -114,11 +123,20 @@ The following algorithms will be used based on the size of the key:
input = Utils.convertToByteString(input, inputType);
+ // Handle NoPadding modes
+ if (noPadding && input.length % 16 !== 0) {
+ throw new OperationError("Input length must be a multiple of 16 bytes for NoPadding modes.");
+ }
const cipher = forge.cipher.createCipher("AES-" + mode, key);
cipher.start({
iv: iv,
additionalData: mode === "GCM" ? aad : undefined
});
+ if (noPadding) {
+ cipher.mode.pad = function(output, options) {
+ return true;
+ };
+ }
cipher.update(forge.util.createBuffer(input));
cipher.finish();
diff --git a/src/core/operations/AESKeyUnwrap.mjs b/src/core/operations/AESKeyUnwrap.mjs
new file mode 100644
index 00000000..1558847a
--- /dev/null
+++ b/src/core/operations/AESKeyUnwrap.mjs
@@ -0,0 +1,128 @@
+/**
+ * @author mikecat
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+import { toHexFast } from "../lib/Hex.mjs";
+import forge from "node-forge";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * AES Key Unwrap operation
+ */
+class AESKeyUnwrap extends Operation {
+
+ /**
+ * AESKeyUnwrap constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "AES Key Unwrap";
+ this.module = "Ciphers";
+ this.description = "Decryptor for a key wrapping algorithm defined in RFC3394, which is used to protect keys in untrusted storage or communications, using AES.
This algorithm uses an AES key (KEK: key-encryption key) and a 64-bit IV to decrypt 64-bit blocks."; + this.infoURL = "https://wikipedia.org/wiki/Key_wrap"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key (KEK)", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "a6a6a6a6a6a6a6a6", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Hex", "Raw"] + }, + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const kek = Utils.convertToByteString(args[0].string, args[0].option), + iv = Utils.convertToByteString(args[1].string, args[1].option), + inputType = args[2], + outputType = args[3]; + + if (kek.length !== 16 && kek.length !== 24 && kek.length !== 32) { + throw new OperationError("KEK must be either 16, 24, or 32 bytes (currently " + kek.length + " bytes)"); + } + if (iv.length !== 8) { + throw new OperationError("IV must be 8 bytes (currently " + iv.length + " bytes)"); + } + const inputData = Utils.convertToByteString(input, inputType); + if (inputData.length % 8 !== 0 || inputData.length < 24) { + throw new OperationError("input must be 8n (n>=3) bytes (currently " + inputData.length + " bytes)"); + } + + const cipher = forge.cipher.createCipher("AES-ECB", kek); + cipher.start(); + cipher.update(forge.util.createBuffer("")); + cipher.finish(); + const paddingBlock = cipher.output.getBytes(); + + const decipher = forge.cipher.createDecipher("AES-ECB", kek); + + let A = inputData.substring(0, 8); + const R = []; + for (let i = 8; i < inputData.length; i += 8) { + R.push(inputData.substring(i, i + 8)); + } + let cntLower = R.length >>> 0; + let cntUpper = (R.length / ((1 << 30) * 4)) >>> 0; + cntUpper = cntUpper * 6 + ((cntLower * 6 / ((1 << 30) * 4)) >>> 0); + cntLower = cntLower * 6 >>> 0; + for (let j = 5; j >= 0; j--) { + for (let i = R.length - 1; i >= 0; i--) { + const aBuffer = Utils.strToArrayBuffer(A); + const aView = new DataView(aBuffer); + aView.setUint32(0, aView.getUint32(0) ^ cntUpper); + aView.setUint32(4, aView.getUint32(4) ^ cntLower); + A = Utils.arrayBufferToStr(aBuffer, false); + decipher.start(); + decipher.update(forge.util.createBuffer(A + R[i] + paddingBlock)); + decipher.finish(); + const B = decipher.output.getBytes(); + A = B.substring(0, 8); + R[i] = B.substring(8, 16); + cntLower--; + if (cntLower < 0) { + cntUpper--; + cntLower = 0xffffffff; + } + } + } + if (A !== iv) { + throw new OperationError("IV mismatch"); + } + const P = R.join(""); + + if (outputType === "Hex") { + return toHexFast(Utils.strToArrayBuffer(P)); + } + return P; + } + +} + +export default AESKeyUnwrap; diff --git a/src/core/operations/AESKeyWrap.mjs b/src/core/operations/AESKeyWrap.mjs new file mode 100644 index 00000000..38867156 --- /dev/null +++ b/src/core/operations/AESKeyWrap.mjs @@ -0,0 +1,115 @@ +/** + * @author mikecat + * @copyright Crown Copyright 2022 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import Utils from "../Utils.mjs"; +import { toHexFast } from "../lib/Hex.mjs"; +import forge from "node-forge"; +import OperationError from "../errors/OperationError.mjs"; + +/** + * AES Key Wrap operation + */ +class AESKeyWrap extends Operation { + + /** + * AESKeyWrap constructor + */ + constructor() { + super(); + + this.name = "AES Key Wrap"; + this.module = "Ciphers"; + this.description = "A key wrapping algorithm defined in RFC3394, which is used to protect keys in untrusted storage or communications, using AES.
This algorithm uses an AES key (KEK: key-encryption key) and a 64-bit IV to encrypt 64-bit blocks."; + this.infoURL = "https://wikipedia.org/wiki/Key_wrap"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key (KEK)", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "a6a6a6a6a6a6a6a6", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Hex", "Raw"] + }, + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const kek = Utils.convertToByteString(args[0].string, args[0].option), + iv = Utils.convertToByteString(args[1].string, args[1].option), + inputType = args[2], + outputType = args[3]; + + if (kek.length !== 16 && kek.length !== 24 && kek.length !== 32) { + throw new OperationError("KEK must be either 16, 24, or 32 bytes (currently " + kek.length + " bytes)"); + } + if (iv.length !== 8) { + throw new OperationError("IV must be 8 bytes (currently " + iv.length + " bytes)"); + } + const inputData = Utils.convertToByteString(input, inputType); + if (inputData.length % 8 !== 0 || inputData.length < 16) { + throw new OperationError("input must be 8n (n>=2) bytes (currently " + inputData.length + " bytes)"); + } + + const cipher = forge.cipher.createCipher("AES-ECB", kek); + + let A = iv; + const R = []; + for (let i = 0; i < inputData.length; i += 8) { + R.push(inputData.substring(i, i + 8)); + } + let cntLower = 1, cntUpper = 0; + for (let j = 0; j < 6; j++) { + for (let i = 0; i < R.length; i++) { + cipher.start(); + cipher.update(forge.util.createBuffer(A + R[i])); + cipher.finish(); + const B = cipher.output.getBytes(); + const msbBuffer = Utils.strToArrayBuffer(B.substring(0, 8)); + const msbView = new DataView(msbBuffer); + msbView.setUint32(0, msbView.getUint32(0) ^ cntUpper); + msbView.setUint32(4, msbView.getUint32(4) ^ cntLower); + A = Utils.arrayBufferToStr(msbBuffer, false); + R[i] = B.substring(8, 16); + cntLower++; + if (cntLower > 0xffffffff) { + cntUpper++; + cntLower = 0; + } + } + } + const C = A + R.join(""); + + if (outputType === "Hex") { + return toHexFast(Utils.strToArrayBuffer(C)); + } + return C; + } + +} + +export default AESKeyWrap; diff --git a/src/core/operations/AMFDecode.mjs b/src/core/operations/AMFDecode.mjs new file mode 100644 index 00000000..50a0d551 --- /dev/null +++ b/src/core/operations/AMFDecode.mjs @@ -0,0 +1,52 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2022 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import "reflect-metadata"; // Required as a shim for the amf library +import { AMF0, AMF3 } from "@astronautlabs/amf"; + +/** + * AMF Decode operation + */ +class AMFDecode extends Operation { + + /** + * AMFDecode constructor + */ + constructor() { + super(); + + this.name = "AMF Decode"; + this.module = "Encodings"; + this.description = "Action Message Format (AMF) is a binary format used to serialize object graphs such as ActionScript objects and XML, or send messages between an Adobe Flash client and a remote service, usually a Flash Media Server or third party alternatives."; + this.infoURL = "https://wikipedia.org/wiki/Action_Message_Format"; + this.inputType = "ArrayBuffer"; + this.outputType = "JSON"; + this.args = [ + { + name: "Format", + type: "option", + value: ["AMF0", "AMF3"], + defaultIndex: 1 + } + ]; + } + + /** + * @param {ArrayBuffer} input + * @param {Object[]} args + * @returns {JSON} + */ + run(input, args) { + const [format] = args; + const handler = format === "AMF0" ? AMF0 : AMF3; + const encoded = new Uint8Array(input); + return handler.Value.deserialize(encoded); + } + +} + +export default AMFDecode; diff --git a/src/core/operations/AMFEncode.mjs b/src/core/operations/AMFEncode.mjs new file mode 100644 index 00000000..c21ba7dc --- /dev/null +++ b/src/core/operations/AMFEncode.mjs @@ -0,0 +1,52 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2022 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import "reflect-metadata"; // Required as a shim for the amf library +import { AMF0, AMF3 } from "@astronautlabs/amf"; + +/** + * AMF Encode operation + */ +class AMFEncode extends Operation { + + /** + * AMFEncode constructor + */ + constructor() { + super(); + + this.name = "AMF Encode"; + this.module = "Encodings"; + this.description = "Action Message Format (AMF) is a binary format used to serialize object graphs such as ActionScript objects and XML, or send messages between an Adobe Flash client and a remote service, usually a Flash Media Server or third party alternatives."; + this.infoURL = "https://wikipedia.org/wiki/Action_Message_Format"; + this.inputType = "JSON"; + this.outputType = "ArrayBuffer"; + this.args = [ + { + name: "Format", + type: "option", + value: ["AMF0", "AMF3"], + defaultIndex: 1 + } + ]; + } + + /** + * @param {JSON} input + * @param {Object[]} args + * @returns {ArrayBuffer} + */ + run(input, args) { + const [format] = args; + const handler = format === "AMF0" ? AMF0 : AMF3; + const output = handler.Value.any(input).serialize(); + return output.buffer; + } + +} + +export default AMFEncode; diff --git a/src/core/operations/AddLineNumbers.mjs b/src/core/operations/AddLineNumbers.mjs index c1c6159a..3eee6544 100644 --- a/src/core/operations/AddLineNumbers.mjs +++ b/src/core/operations/AddLineNumbers.mjs @@ -22,7 +22,13 @@ class AddLineNumbers extends Operation { this.description = "Adds line numbers to the output."; this.inputType = "string"; this.outputType = "string"; - this.args = []; + this.args = [ + { + "name": "Offset", + "type": "number", + "value": 0 + } + ]; } /** @@ -33,10 +39,11 @@ class AddLineNumbers extends Operation { run(input, args) { const lines = input.split("\n"), width = lines.length.toString().length; + const offset = args[0] ? parseInt(args[0], 10) : 0; let output = ""; for (let n = 0; n < lines.length; n++) { - output += (n+1).toString().padStart(width, " ") + " " + lines[n] + "\n"; + output += (n+1+offset).toString().padStart(width, " ") + " " + lines[n] + "\n"; } return output.slice(0, output.length-1); } diff --git a/src/core/operations/AddTextToImage.mjs b/src/core/operations/AddTextToImage.mjs index 231de14f..c137b492 100644 --- a/src/core/operations/AddTextToImage.mjs +++ b/src/core/operations/AddTextToImage.mjs @@ -9,14 +9,19 @@ import OperationError from "../errors/OperationError.mjs"; import { isImage } from "../lib/FileType.mjs"; import { toBase64 } from "../lib/Base64.mjs"; import { isWorkerEnvironment } from "../Utils.mjs"; -import jimplib from "jimp/es/index.js"; -const jimp = jimplib.default ? jimplib.default : jimplib; +import { + Jimp, + JimpMime, + ResizeStrategy, + measureText, + measureTextHeight, + loadFont, +} from "jimp"; /** * Add Text To Image operation */ class AddTextToImage extends Operation { - /** * AddTextToImage constructor */ @@ -25,7 +30,8 @@ class AddTextToImage extends Operation { this.name = "Add Text To Image"; this.module = "Image"; - this.description = "Adds text onto an image.
Text can be horizontally or vertically aligned, or the position can be manually specified.
Variants of the Roboto font face are available in any size or colour."; + this.description = + "Adds text onto an image.
Text can be horizontally or vertically aligned, or the position can be manually specified.
Variants of the Roboto font face are available in any size or colour."; this.infoURL = ""; this.inputType = "ArrayBuffer"; this.outputType = "ArrayBuffer"; @@ -34,72 +40,67 @@ class AddTextToImage extends Operation { { name: "Text", type: "string", - value: "" + value: "", }, { name: "Horizontal align", type: "option", - value: ["None", "Left", "Center", "Right"] + value: ["None", "Left", "Center", "Right"], }, { name: "Vertical align", type: "option", - value: ["None", "Top", "Middle", "Bottom"] + value: ["None", "Top", "Middle", "Bottom"], }, { name: "X position", type: "number", - value: 0 + value: 0, }, { name: "Y position", type: "number", - value: 0 + value: 0, }, { name: "Size", type: "number", value: 32, - min: 8 + min: 8, }, { name: "Font face", type: "option", - value: [ - "Roboto", - "Roboto Black", - "Roboto Mono", - "Roboto Slab" - ] + value: ["Roboto", "Roboto Black", "Roboto Mono", "Roboto Slab"], }, { name: "Red", type: "number", value: 255, min: 0, - max: 255 + max: 255, }, { name: "Green", type: "number", value: 255, min: 0, - max: 255 + max: 255, }, { name: "Blue", type: "number", value: 255, min: 0, - max: 255 + max: 255, }, { name: "Alpha", type: "number", value: 255, min: 0, - max: 255 - } + max: 255, + }, ]; } @@ -128,45 +129,64 @@ class AddTextToImage extends Operation { let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error loading image. (${err})`); } - try { - if (isWorkerEnvironment()) - self.sendStatusMessage("Adding text to image..."); - const fontsMap = {}; + if (isWorkerEnvironment()) + self.sendStatusMessage("Adding text to image..."); + + const fontsMap = {}; + try { const fonts = [ - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.fnt"), - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.fnt"), - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.fnt"), - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.fnt") + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.fnt" + ), + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.fnt" + ), + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.fnt" + ), + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.fnt" + ), ]; - await Promise.all(fonts) - .then(fonts => { - fontsMap.Roboto = fonts[0]; - fontsMap["Roboto Black"] = fonts[1]; - fontsMap["Roboto Mono"] = fonts[2]; - fontsMap["Roboto Slab"] = fonts[3]; - }); - - + await Promise.all(fonts).then((fonts) => { + fontsMap.Roboto = fonts[0]; + fontsMap["Roboto Black"] = fonts[1]; + fontsMap["Roboto Mono"] = fonts[2]; + fontsMap["Roboto Slab"] = fonts[3]; + }); // Make Webpack load the png font images await Promise.all([ - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.png"), - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.png"), - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.png"), - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.png") + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.png" + ), + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.png" + ), + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.png" + ), + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.png" + ), ]); + } catch (err) { + throw new OperationError(`Error preparing fonts. (${err})`); + } + let jimpFont; + try { const font = fontsMap[fontFace]; // LoadFont needs an absolute url, so append the font name to self.docURL - const jimpFont = await jimp.loadFont(self.docURL + "/" + font.default); + jimpFont = await loadFont(self.docURL + "/" + font.default); - jimpFont.pages.forEach(function(page) { + jimpFont.pages.forEach(function (page) { if (page.bitmap) { // Adjust the RGB values of the image pages to change the font colour. const pageWidth = page.bitmap.width; @@ -176,32 +196,56 @@ class AddTextToImage extends Operation { const idx = (iy * pageWidth + ix) << 2; const newRed = page.bitmap.data[idx] - (255 - red); - const newGreen = page.bitmap.data[idx + 1] - (255 - green); - const newBlue = page.bitmap.data[idx + 2] - (255 - blue); - const newAlpha = page.bitmap.data[idx + 3] - (255 - alpha); + const newGreen = + page.bitmap.data[idx + 1] - (255 - green); + const newBlue = + page.bitmap.data[idx + 2] - (255 - blue); + const newAlpha = + page.bitmap.data[idx + 3] - (255 - alpha); // Make sure the bitmap values don't go below 0 as that makes jimp very unhappy - page.bitmap.data[idx] = (newRed > 0) ? newRed : 0; - page.bitmap.data[idx + 1] = (newGreen > 0) ? newGreen : 0; - page.bitmap.data[idx + 2] = (newBlue > 0) ? newBlue : 0; - page.bitmap.data[idx + 3] = (newAlpha > 0) ? newAlpha : 0; + page.bitmap.data[idx] = newRed > 0 ? newRed : 0; + page.bitmap.data[idx + 1] = + newGreen > 0 ? newGreen : 0; + page.bitmap.data[idx + 2] = + newBlue > 0 ? newBlue : 0; + page.bitmap.data[idx + 3] = + newAlpha > 0 ? newAlpha : 0; } } } }); + } catch (err) { + throw new OperationError(`Error loading font. (${err})`); + } + try { // Create a temporary image to hold the rendered text - const textImage = new jimp(jimp.measureText(jimpFont, text), jimp.measureTextHeight(jimpFont, text)); - textImage.print(jimpFont, 0, 0, text); + const textImage = new Jimp({ + width: measureText(jimpFont, text), + height: measureTextHeight(jimpFont, text), + }); + textImage.print({ + font: jimpFont, + x: 0, + y: 0, + text, + }); // Scale the rendered text image to the correct size const scaleFactor = size / 72; if (size !== 1) { // Use bicubic for decreasing size if (size > 1) { - textImage.scale(scaleFactor, jimp.RESIZE_BICUBIC); + textImage.scale({ + f: scaleFactor, + mode: ResizeStrategy.BICUBIC, + }); } else { - textImage.scale(scaleFactor, jimp.RESIZE_BILINEAR); + textImage.scale({ + f: scaleFactor, + mode: ResizeStrategy.BILINEAR, + }); } } @@ -211,10 +255,10 @@ class AddTextToImage extends Operation { xPos = 0; break; case "Center": - xPos = (image.getWidth() / 2) - (textImage.getWidth() / 2); + xPos = image.width / 2 - textImage.width / 2; break; case "Right": - xPos = image.getWidth() - textImage.getWidth(); + xPos = image.width - textImage.width; break; } @@ -223,25 +267,33 @@ class AddTextToImage extends Operation { yPos = 0; break; case "Middle": - yPos = (image.getHeight() / 2) - (textImage.getHeight() / 2); + yPos = image.height / 2 - textImage.height / 2; break; case "Bottom": - yPos = image.getHeight() - textImage.getHeight(); + yPos = image.height - textImage.height; break; } // Blit the rendered text image onto the original source image - image.blit(textImage, xPos, yPos); + image.blit({ + src: textImage, + x: xPos, + y: yPos, + }); + } catch (err) { + throw new OperationError(`Error adding text to image. (${err})`); + } + try { let imageBuffer; - if (image.getMIME() === "image/gif") { - imageBuffer = await image.getBufferAsync(jimp.MIME_PNG); + if (image.mime === "image/gif") { + imageBuffer = await image.getBuffer(JimpMime.png); } else { - imageBuffer = await image.getBufferAsync(jimp.AUTO); + imageBuffer = await image.getBuffer(image.mime); } return imageBuffer.buffer; } catch (err) { - throw new OperationError(`Error adding text to image. (${err})`); + throw new OperationError(`Error exporting image. (${err})`); } } @@ -262,7 +314,6 @@ class AddTextToImage extends Operation { return `})
`;
}
-
}
export default AddTextToImage;
diff --git a/src/core/operations/AlternatingCaps.mjs b/src/core/operations/AlternatingCaps.mjs
new file mode 100644
index 00000000..2d54867c
--- /dev/null
+++ b/src/core/operations/AlternatingCaps.mjs
@@ -0,0 +1,53 @@
+/**
+ * @author sw5678
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * Alternating caps operation
+ */
+class AlternatingCaps extends Operation {
+
+ /**
+ * AlternatingCaps constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "Alternating Caps";
+ this.module = "Default";
+ this.description = "Alternating caps, also known as studly caps, sticky caps, or spongecase is a form of text notation in which the capitalization of letters varies by some pattern, or arbitrarily. An example of this would be spelling 'alternative caps' as 'aLtErNaTiNg CaPs'.";
+ this.infoURL = "https://en.wikipedia.org/wiki/Alternating_caps";
+ this.inputType = "string";
+ this.outputType = "string";
+ this.args= [];
+ }
+
+ /**
+ * @param {string} input
+ * @param {Object[]} args
+ * @returns {string}
+ */
+ run(input, args) {
+ let output = "";
+ let previousCaps = true;
+ for (let i = 0; i < input.length; i++) {
+ // Check if the element is a letter
+ if (!RegExp(/^\p{L}/, "u").test(input[i])) {
+ output += input[i];
+ } else if (previousCaps) {
+ output += input[i].toLowerCase();
+ previousCaps = false;
+ } else {
+ output += input[i].toUpperCase();
+ previousCaps = true;
+ }
+ }
+ return output;
+ }
+}
+
+export default AlternatingCaps;
diff --git a/src/core/operations/AnalyseUUID.mjs b/src/core/operations/AnalyseUUID.mjs
new file mode 100644
index 00000000..6f960c8a
--- /dev/null
+++ b/src/core/operations/AnalyseUUID.mjs
@@ -0,0 +1,151 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @author ko80240 [csk.dev@proton.me]
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import * as uuid from "uuid";
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { toHex } from "../lib/Hex.mjs";
+
+/**
+ * Analyse UUID operation
+ */
+class AnalyseUUID extends Operation {
+
+ /**
+ * AnalyseUUID constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "Analyse UUID";
+ this.module = "Crypto";
+ this.description = "Operation for extracting metadata and detecting the version of a given UUID.";
+ this.infoURL = "https://wikipedia.org/wiki/Universally_unique_identifier";
+ this.inputType = "string";
+ this.outputType = "string";
+ this.args = [
+ {
+ name: "Include Metadata",
+ type: "boolean",
+ value: true
+ }
+ ];
+ }
+
+ /**
+ * @param {string} input - Expects a valid UUID string
+ * @param {Object[]} args
+ * @returns {string}
+ */
+ run(input, args) {
+ input = input.trim();
+
+ let uuidVersion, uuidBytes;
+ try {
+ uuidVersion = uuid.version(input); // Re-using the uuid library to extract version
+ uuidBytes = uuid.parse(input); // Re-using the uuid library to parse bytes
+ } catch (error) {
+ throw new OperationError("Invalid UUID");
+ }
+
+ const [includeMetadata] = args;
+ const dv = new DataView(uuidBytes.buffer, uuidBytes.byteOffset, uuidBytes.byteLength); // Dataview helps handle the multi-byte ints
+ const uuidInteger = (dv.getBigUint64(0) << 64n) | dv.getBigUint64(8);
+
+ const sections = [`Version:\n${uuidVersion}`];
+
+ if (includeMetadata) {
+ const parser = UUID_PARSERS[uuidVersion];
+ const decoded = parser?.(uuidBytes, dv);
+ sections.push(formatDecoded(decoded));
+ }
+
+ sections.push(`UUID Integer:\n${uuidInteger}`);
+
+ return sections.filter(Boolean).join("\n\n");
+ }
+}
+
+export default AnalyseUUID;
+
+/**
+ * Metadata can be extracted for versions 1, 6, and 7.
+ * Enum-like frozen mapping of UUID version to parser function.
+ */
+const UUID_PARSERS = Object.freeze({
+ 1: parsev1v6,
+ 6: parsev1v6,
+ 7: parsev7,
+});
+
+/**
+ * Versions 1 and 6. Note 6 is a re-order of 1.
+ * Version 1 == layout: timeLow(32) | timeMid(16) | timeHi(12)
+ * Version 6 == layout: timeHi(32) | timeMid(16) | timeLow(12)
+ */
+function parsev1v6(uuidBytes, dv) {
+ const isV1 = (uuidBytes[6] >> 4) === 1;
+
+ const timeStamp =
+ isV1 ? (
+ (BigInt(dv.getUint16(6) & 0x0fff) << 48n) | // mask off version bits
+ (BigInt(dv.getUint16(4)) << 32n) |
+ BigInt(dv.getUint32(0))
+ ) : (
+ (BigInt(dv.getUint32(0)) << 28n) |
+ (BigInt(dv.getUint16(4)) << 12n) |
+ (BigInt(dv.getUint16(6) & 0x0fff))
+ );
+
+ // Convert to Unix time
+ const milliseconds =
+ Number(
+ (timeStamp - 122192928000000000n) / 10000n
+ );
+
+ return {
+ timestamp: milliseconds,
+ isoTimestamp: new Date(milliseconds).toISOString(),
+ clock: ((uuidBytes[8] & 0x3f) << 8) | uuidBytes[9],
+ node: toHex(uuidBytes.slice(10), ":").toUpperCase()
+ };
+}
+
+/** Version 7 */
+function parsev7(uuidBytes, dv) {
+ const milliseconds = Number((BigInt(dv.getUint32(0)) << 16n) | BigInt(dv.getUint16(4)));
+
+ return {
+ timestamp: milliseconds,
+ isoTimestamp: new Date(milliseconds).toISOString(),
+ randA: ((uuidBytes[6] & 0x0f) << 8) | uuidBytes[7],
+ randB: toHex(uuidBytes.slice(8), "").toUpperCase()
+ };
+}
+
+/**
+ * Formats metadata
+ *
+ * @param {Object|undefined} decoded
+ * @returns {string}
+ */
+function formatDecoded(decoded) {
+ if (!decoded) return "No metadata available. Only versions 1, 6, 7 are supported.";
+
+ return Object.entries({
+ "Timestamp": decoded.timestamp,
+ "Timestamp (ISO)": decoded.isoTimestamp,
+ "Node": decoded.node,
+ "Clock": decoded.clock,
+ "Rand A": decoded.randA,
+ "Rand B": decoded.randB
+ })
+ .filter(([, value]) => value !== undefined)
+ .map(([label, value]) => `${label}:\n${value}`)
+ .join("\n\n");
+}
diff --git a/src/core/operations/Argon2.mjs b/src/core/operations/Argon2.mjs
new file mode 100644
index 00000000..4feb881c
--- /dev/null
+++ b/src/core/operations/Argon2.mjs
@@ -0,0 +1,117 @@
+/**
+ * @author Tan Zhen Yong [tzy@beyondthesprawl.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import argon2 from "argon2-browser";
+
+/**
+ * Argon2 operation
+ */
+class Argon2 extends Operation {
+
+ /**
+ * Argon2 constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "Argon2";
+ this.module = "Crypto";
+ this.description = "Argon2 is a key derivation function that was selected as the winner of the Password Hashing Competition in July 2015. It was designed by Alex Biryukov, Daniel Dinu, and Dmitry Khovratovich from the University of Luxembourg.
Enter the password in the input to generate its hash."; + this.infoURL = "https://wikipedia.org/wiki/Argon2"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Salt", + "type": "toggleString", + "value": "somesalt", + "toggleValues": ["UTF8", "Hex", "Base64", "Latin1"] + }, + { + "name": "Iterations", + "type": "number", + "value": 3 + }, + { + "name": "Memory (KiB)", + "type": "number", + "value": 4096 + }, + { + "name": "Parallelism", + "type": "number", + "value": 1 + }, + { + "name": "Hash length (bytes)", + "type": "number", + "value": 32 + }, + { + "name": "Type", + "type": "option", + "value": ["Argon2i", "Argon2d", "Argon2id"], + "defaultIndex": 0 + }, + { + "name": "Output format", + "type": "option", + "value": ["Encoded hash", "Hex hash", "Raw hash"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + async run(input, args) { + const argon2Types = { + "Argon2i": argon2.ArgonType.Argon2i, + "Argon2d": argon2.ArgonType.Argon2d, + "Argon2id": argon2.ArgonType.Argon2id + }; + + const salt = Utils.convertToByteString(args[0].string || "", args[0].option), + time = args[1], + mem = args[2], + parallelism = args[3], + hashLen = args[4], + type = argon2Types[args[5]], + outFormat = args[6]; + + try { + const result = await argon2.hash({ + pass: input, + salt, + time, + mem, + parallelism, + hashLen, + type, + }); + + switch (outFormat) { + case "Hex hash": + return result.hashHex; + case "Raw hash": + return Utils.arrayBufferToStr(result.hash); + case "Encoded hash": + default: + return result.encoded; + } + } catch (err) { + throw new OperationError(`Error: ${err.message}`); + } + } + +} + +export default Argon2; diff --git a/src/core/operations/Argon2Compare.mjs b/src/core/operations/Argon2Compare.mjs new file mode 100644 index 00000000..68e48ed0 --- /dev/null +++ b/src/core/operations/Argon2Compare.mjs @@ -0,0 +1,58 @@ +/** + * @author Tan Zhen Yong [tzy@beyondthesprawl.com] + * @copyright Crown Copyright 2019 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import argon2 from "argon2-browser"; + +/** + * Argon2 compare operation + */ +class Argon2Compare extends Operation { + + /** + * Argon2Compare constructor + */ + constructor() { + super(); + + this.name = "Argon2 compare"; + this.module = "Crypto"; + this.description = "Tests whether the input matches the given Argon2 hash. To test multiple possible passwords, use the 'Fork' operation."; + this.infoURL = "https://wikipedia.org/wiki/Argon2"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Encoded hash", + "type": "string", + "value": "" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + async run(input, args) { + const encoded = args[0]; + + try { + await argon2.verify({ + pass: input, + encoded + }); + + return `Match: ${input}`; + } catch (err) { + return "No match"; + } + } + +} + +export default Argon2Compare; diff --git a/src/core/operations/BLAKE3.mjs b/src/core/operations/BLAKE3.mjs new file mode 100644 index 00000000..0f686120 --- /dev/null +++ b/src/core/operations/BLAKE3.mjs @@ -0,0 +1,58 @@ +/** + * @author xumptex [xumptex@outlook.fr] + * @copyright Crown Copyright 2025 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import OperationError from "../errors/OperationError.mjs"; +import { blake3 } from "hash-wasm"; +/** + * BLAKE3 operation + */ +class BLAKE3 extends Operation { + + /** + * BLAKE3 constructor + */ + constructor() { + super(); + + this.name = "BLAKE3"; + this.module = "Hashing"; + this.description = "Hashes the input using BLAKE3 (UTF-8 encoded), with an optional key (also UTF-8), and outputs the result in hexadecimal format."; + this.infoURL = "https://en.wikipedia.org/wiki/BLAKE_(hash_function)#BLAKE3"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Size (bytes)", + "type": "number" + }, { + "name": "Key", + "type": "string", + "value": "" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = args[1]; + const size = args[0]; + // Check if the user want a key hash or not + if (key === "") { + return blake3(input, size*8); + } if (key.length !== 32) { + throw new OperationError("The key must be exactly 32 bytes long"); + } + return blake3(input, size*8, key); + } + +} + +export default BLAKE3; diff --git a/src/core/operations/BlowfishDecrypt.mjs b/src/core/operations/BlowfishDecrypt.mjs index f7dc8d17..afb26007 100644 --- a/src/core/operations/BlowfishDecrypt.mjs +++ b/src/core/operations/BlowfishDecrypt.mjs @@ -70,10 +70,14 @@ class BlowfishDecrypt extends Operation { inputType = args[3], outputType = args[4]; - if (key.length !== 8) { + if (key.length < 4 || key.length > 56) { throw new OperationError(`Invalid key length: ${key.length} bytes -Blowfish uses a key length of 8 bytes (64 bits).`); +Blowfish's key length needs to be between 4 and 56 bytes (32-448 bits).`); + } + + if (mode !== "ECB" && iv.length !== 8) { + throw new OperationError(`Invalid IV length: ${iv.length} bytes. Expected 8 bytes.`); } input = Utils.convertToByteString(input, inputType); diff --git a/src/core/operations/BlowfishEncrypt.mjs b/src/core/operations/BlowfishEncrypt.mjs index 2cf3672b..1d5dcf02 100644 --- a/src/core/operations/BlowfishEncrypt.mjs +++ b/src/core/operations/BlowfishEncrypt.mjs @@ -70,10 +70,14 @@ class BlowfishEncrypt extends Operation { inputType = args[3], outputType = args[4]; - if (key.length !== 8) { + if (key.length < 4 || key.length > 56) { throw new OperationError(`Invalid key length: ${key.length} bytes -Blowfish uses a key length of 8 bytes (64 bits).`); +Blowfish's key length needs to be between 4 and 56 bytes (32-448 bits).`); + } + + if (mode !== "ECB" && iv.length !== 8) { + throw new OperationError(`Invalid IV length: ${iv.length} bytes. Expected 8 bytes.`); } input = Utils.convertToByteString(input, inputType); diff --git a/src/core/operations/BlurImage.mjs b/src/core/operations/BlurImage.mjs index 5ae383a2..ba46080f 100644 --- a/src/core/operations/BlurImage.mjs +++ b/src/core/operations/BlurImage.mjs @@ -9,15 +9,12 @@ import OperationError from "../errors/OperationError.mjs"; import { isWorkerEnvironment } from "../Utils.mjs"; import { isImage } from "../lib/FileType.mjs"; import { toBase64 } from "../lib/Base64.mjs"; -import { gaussianBlur } from "../lib/ImageManipulation.mjs"; -import jimplib from "jimp/es/index.js"; -const jimp = jimplib.default ? jimplib.default : jimplib; +import { Jimp, JimpMime } from "jimp"; /** * Blur Image operation */ class BlurImage extends Operation { - /** * BlurImage constructor */ @@ -26,7 +23,8 @@ class BlurImage extends Operation { this.name = "Blur Image"; this.module = "Image"; - this.description = "Applies a blur effect to the image.
Gaussian blur is much slower than fast blur, but produces better results."; + this.description = + "Applies a blur effect to the image.
Gaussian blur is much slower than fast blur, but produces better results."; this.infoURL = "https://wikipedia.org/wiki/Gaussian_blur"; this.inputType = "ArrayBuffer"; this.outputType = "ArrayBuffer"; @@ -36,13 +34,13 @@ class BlurImage extends Operation { name: "Amount", type: "number", value: 5, - min: 1 + min: 1, }, { name: "Type", type: "option", - value: ["Fast", "Gaussian"] - } + value: ["Fast", "Gaussian"], + }, ]; } @@ -60,7 +58,7 @@ class BlurImage extends Operation { let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error loading image. (${err})`); } @@ -74,15 +72,15 @@ class BlurImage extends Operation { case "Gaussian": if (isWorkerEnvironment()) self.sendStatusMessage("Gaussian blurring image..."); - image = gaussianBlur(image, blurAmount); + image.gaussian(blurAmount); break; } let imageBuffer; - if (image.getMIME() === "image/gif") { - imageBuffer = await image.getBufferAsync(jimp.MIME_PNG); + if (image.mime === "image/gif") { + imageBuffer = await image.getBuffer(JimpMime.png); } else { - imageBuffer = await image.getBufferAsync(jimp.AUTO); + imageBuffer = await image.getBuffer(image.mime); } return imageBuffer.buffer; } catch (err) { @@ -107,7 +105,6 @@ class BlurImage extends Operation { return ``;
}
-
}
export default BlurImage;
diff --git a/src/core/operations/CMAC.mjs b/src/core/operations/CMAC.mjs
new file mode 100644
index 00000000..d6491362
--- /dev/null
+++ b/src/core/operations/CMAC.mjs
@@ -0,0 +1,149 @@
+/**
+ * @author mikecat
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+import forge from "node-forge";
+import { toHexFast } from "../lib/Hex.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * CMAC operation
+ */
+class CMAC extends Operation {
+
+ /**
+ * CMAC constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "CMAC";
+ this.module = "Crypto";
+ this.description = "CMAC is a block-cipher based message authentication code algorithm.
RFC4493 defines AES-CMAC that uses AES encryption with a 128-bit key.
NIST SP 800-38B suggests usages of AES with other key lengths and Triple DES."; + this.infoURL = "https://wikipedia.org/wiki/CMAC"; + this.inputType = "ArrayBuffer"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Encryption algorithm", + "type": "option", + "value": ["AES", "Triple DES"] + } + ]; + } + + /** + * @param {ArrayBuffer} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteString(args[0].string, args[0].option); + const algo = args[1]; + + const info = (function() { + switch (algo) { + case "AES": + if (key.length !== 16 && key.length !== 24 && key.length !== 32) { + throw new OperationError("The key for AES must be either 16, 24, or 32 bytes (currently " + key.length + " bytes)"); + } + return { + "algorithm": "AES-ECB", + "key": key, + "blockSize": 16, + "Rb": new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x87]), + }; + case "Triple DES": + if (key.length !== 16 && key.length !== 24) { + throw new OperationError("The key for Triple DES must be 16 or 24 bytes (currently " + key.length + " bytes)"); + } + return { + "algorithm": "3DES-ECB", + "key": key.length === 16 ? key + key.substring(0, 8) : key, + "blockSize": 8, + "Rb": new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0x1b]), + }; + default: + throw new OperationError("Undefined encryption algorithm"); + } + })(); + + const xor = function(a, b, out) { + if (!out) out = new Uint8Array(a.length); + for (let i = 0; i < a.length; i++) { + out[i] = a[i] ^ b[i]; + } + return out; + }; + + const leftShift1 = function(a) { + const out = new Uint8Array(a.length); + let carry = 0; + for (let i = a.length - 1; i >= 0; i--) { + out[i] = (a[i] << 1) | carry; + carry = a[i] >> 7; + } + return out; + }; + + const cipher = forge.cipher.createCipher(info.algorithm, info.key); + const encrypt = function(a, out) { + if (!out) out = new Uint8Array(a.length); + cipher.start(); + cipher.update(forge.util.createBuffer(a)); + cipher.finish(); + const cipherText = cipher.output.getBytes(); + for (let i = 0; i < a.length; i++) { + out[i] = cipherText.charCodeAt(i); + } + return out; + }; + + const L = encrypt(new Uint8Array(info.blockSize)); + const K1 = leftShift1(L); + if (L[0] & 0x80) xor(K1, info.Rb, K1); + const K2 = leftShift1(K1); + if (K1[0] & 0x80) xor(K2, info.Rb, K2); + + const n = Math.ceil(input.byteLength / info.blockSize); + const lastBlock = (function() { + if (n === 0) { + const data = new Uint8Array(K2); + data[0] ^= 0x80; + return data; + } + const inputLast = new Uint8Array(input, info.blockSize * (n - 1)); + if (inputLast.length === info.blockSize) { + return xor(inputLast, K1, inputLast); + } else { + const data = new Uint8Array(info.blockSize); + data.set(inputLast, 0); + data[inputLast.length] = 0x80; + return xor(data, K2, data); + } + })(); + + const X = new Uint8Array(info.blockSize); + const Y = new Uint8Array(info.blockSize); + for (let i = 0; i < n - 1; i++) { + xor(X, new Uint8Array(input, info.blockSize * i, info.blockSize), Y); + encrypt(Y, X); + } + xor(lastBlock, X, Y); + const T = encrypt(Y); + return toHexFast(T); + } + +} + +export default CMAC; diff --git a/src/core/operations/CRC16Checksum.mjs b/src/core/operations/CRC16Checksum.mjs deleted file mode 100644 index 035ee04b..00000000 --- a/src/core/operations/CRC16Checksum.mjs +++ /dev/null @@ -1,41 +0,0 @@ -/** - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - */ - -import Operation from "../Operation.mjs"; -import JSCRC from "js-crc"; - -/** - * CRC-16 Checksum operation - */ -class CRC16Checksum extends Operation { - - /** - * CRC16Checksum constructor - */ - constructor() { - super(); - - this.name = "CRC-16 Checksum"; - this.module = "Crypto"; - this.description = "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.
The CRC was invented by W. Wesley Peterson in 1961."; - this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check"; - this.inputType = "ArrayBuffer"; - this.outputType = "string"; - this.args = []; - } - - /** - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - run(input, args) { - return JSCRC.crc16(input); - } - -} - -export default CRC16Checksum; diff --git a/src/core/operations/CRC32Checksum.mjs b/src/core/operations/CRC32Checksum.mjs deleted file mode 100644 index cfe84643..00000000 --- a/src/core/operations/CRC32Checksum.mjs +++ /dev/null @@ -1,41 +0,0 @@ -/** - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - */ - -import Operation from "../Operation.mjs"; -import JSCRC from "js-crc"; - -/** - * CRC-32 Checksum operation - */ -class CRC32Checksum extends Operation { - - /** - * CRC32Checksum constructor - */ - constructor() { - super(); - - this.name = "CRC-32 Checksum"; - this.module = "Crypto"; - this.description = "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.
The CRC was invented by W. Wesley Peterson in 1961; the 32-bit CRC function of Ethernet and many other standards is the work of several researchers and was published in 1975."; - this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check"; - this.inputType = "ArrayBuffer"; - this.outputType = "string"; - this.args = []; - } - - /** - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - run(input, args) { - return JSCRC.crc32(input); - } - -} - -export default CRC32Checksum; diff --git a/src/core/operations/CRC8Checksum.mjs b/src/core/operations/CRC8Checksum.mjs deleted file mode 100644 index 193cadf9..00000000 --- a/src/core/operations/CRC8Checksum.mjs +++ /dev/null @@ -1,157 +0,0 @@ -/** - * @author mshwed [m@ttshwed.com] - * @copyright Crown Copyright 2019 - * @license Apache-2.0 - */ - -import Operation from "../Operation.mjs"; -import OperationError from "../errors/OperationError.mjs"; - -import { toHexFast } from "../lib/Hex.mjs"; - -/** - * CRC-8 Checksum operation - */ -class CRC8Checksum extends Operation { - - /** - * CRC8Checksum constructor - */ - constructor() { - super(); - - this.name = "CRC-8 Checksum"; - this.module = "Crypto"; - this.description = "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.
The CRC was invented by W. Wesley Peterson in 1961."; - this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check"; - this.inputType = "ArrayBuffer"; - this.outputType = "string"; - this.args = [ - { - "name": "Algorithm", - "type": "option", - "value": [ - "CRC-8", - "CRC-8/CDMA2000", - "CRC-8/DARC", - "CRC-8/DVB-S2", - "CRC-8/EBU", - "CRC-8/I-CODE", - "CRC-8/ITU", - "CRC-8/MAXIM", - "CRC-8/ROHC", - "CRC-8/WCDMA" - ] - } - ]; - } - - /** - * Generates the pre-computed lookup table for byte division - * - * @param polynomial - */ - calculateCRC8LookupTable(polynomial) { - const crc8Table = new Uint8Array(256); - - let currentByte; - for (let i = 0; i < 256; i++) { - currentByte = i; - for (let bit = 0; bit < 8; bit++) { - if ((currentByte & 0x80) !== 0) { - currentByte <<= 1; - currentByte ^= polynomial; - } else { - currentByte <<= 1; - } - } - - crc8Table[i] = currentByte; - } - - return crc8Table; - } - - /** - * Calculates the CRC-8 Checksum from an input - * - * @param {ArrayBuffer} input - * @param {number} polynomial - * @param {number} initializationValue - * @param {boolean} inputReflection - * @param {boolean} outputReflection - * @param {number} xorOut - */ - calculateCRC8(input, polynomial, initializationValue, inputReflection, outputReflection, xorOut) { - const crcSize = 8; - const crcTable = this.calculateCRC8LookupTable(polynomial); - - let crc = initializationValue !== 0 ? initializationValue : 0; - let currentByte, position; - - input = new Uint8Array(input); - for (const inputByte of input) { - currentByte = inputReflection ? this.reverseBits(inputByte, crcSize) : inputByte; - - position = (currentByte ^ crc) & 255; - crc = crcTable[position]; - } - - crc = outputReflection ? this.reverseBits(crc, crcSize) : crc; - - if (xorOut !== 0) crc = crc ^ xorOut; - - return toHexFast(new Uint8Array([crc])); - } - - /** - * Reverse the bits for a given input byte. - * - * @param {number} input - */ - reverseBits(input, hashSize) { - let reversedByte = 0; - for (let i = hashSize - 1; i >= 0; i--) { - reversedByte |= ((input & 1) << i); - input >>= 1; - } - - return reversedByte; - } - - /** - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - run(input, args) { - const algorithm = args[0]; - - switch (algorithm) { - case "CRC-8": - return this.calculateCRC8(input, 0x7, 0x0, false, false, 0x0); - case "CRC-8/CDMA2000": - return this.calculateCRC8(input, 0x9B, 0xFF, false, false, 0x0); - case "CRC-8/DARC": - return this.calculateCRC8(input, 0x39, 0x0, true, true, 0x0); - case "CRC-8/DVB-S2": - return this.calculateCRC8(input, 0xD5, 0x0, false, false, 0x0); - case "CRC-8/EBU": - return this.calculateCRC8(input, 0x1D, 0xFF, true, true, 0x0); - case "CRC-8/I-CODE": - return this.calculateCRC8(input, 0x1D, 0xFD, false, false, 0x0); - case "CRC-8/ITU": - return this.calculateCRC8(input, 0x7, 0x0, false, false, 0x55); - case "CRC-8/MAXIM": - return this.calculateCRC8(input, 0x31, 0x0, true, true, 0x0); - case "CRC-8/ROHC": - return this.calculateCRC8(input, 0x7, 0xFF, true, true, 0x0); - case "CRC-8/WCDMA": - return this.calculateCRC8(input, 0x9B, 0x0, true, true, 0x0); - default: - throw new OperationError("Unknown checksum algorithm"); - } - } -} - -export default CRC8Checksum; diff --git a/src/core/operations/CRCChecksum.mjs b/src/core/operations/CRCChecksum.mjs new file mode 100644 index 00000000..88da2fa5 --- /dev/null +++ b/src/core/operations/CRCChecksum.mjs @@ -0,0 +1,1110 @@ +/** + * @author r4mos [2k95ljkhg@mozmail.com] + * @copyright Crown Copyright 2025 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import OperationError from "../errors/OperationError.mjs"; + +/** + * CRC Checksum operation + */ +class CRCChecksum extends Operation { + + /** + * CRCChecksum constructor + */ + constructor() { + super(); + + this.name = "CRC Checksum"; + this.module = "Default"; + this.description = "A Cyclic Redundancy Check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data."; + this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check"; + this.inputType = "ArrayBuffer"; + this.outputType = "string"; + this.args = [ + { + name: "Algorithm", + type: "argSelector", + value: [ + { + name: "Custom", + on: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-3/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-3/ROHC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-4/G-704", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-4/INTERLAKEN", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-4/ITU", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-5/EPC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-5/EPC-C1G2", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-5/G-704", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-5/ITU", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-5/USB", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-6/CDMA2000-A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-6/CDMA2000-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-6/DARC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-6/G-704", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-6/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-6/ITU", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-7/MMC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-7/ROHC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-7/UMTS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/8H2F", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/AES", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/AUTOSAR", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/BLUETOOTH", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/CDMA2000", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/DARC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/DVB-S2", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/EBU", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/GSM-A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/GSM-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/HITAG", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/I-432-1", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/I-CODE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/ITU", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/LTE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/MAXIM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/MAXIM-DOW", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/MIFARE-MAD", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/NRSC-5", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/OPENSAFETY", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/ROHC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/SAE-J1850", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/SAE-J1850-ZERO", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/SMBUS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/TECH-3250", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/WCDMA", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-10/ATM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-10/CDMA2000", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-10/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-10/I-610", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-11/FLEXRAY", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-11/UMTS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-12/3GPP", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-12/CDMA2000", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-12/DECT", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-12/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-12/UMTS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-13/BBC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-14/DARC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-14/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-15/CAN", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-15/MPT1327", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/ACORN", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/ARC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/AUG-CCITT", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/AUTOSAR", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/BLUETOOTH", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/BUYPASS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/CCITT", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/CCITT-FALSE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/CCITT-TRUE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/CCITT-ZERO", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/CDMA2000", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/CMS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/DARC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/DDS-110", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/DECT-R", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/DECT-X", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/DNP", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/EN-13757", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/EPC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/EPC-C1G2", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/GENIBUS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/I-CODE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/IBM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/IBM-3740", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/IBM-SDLC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/IEC-61158-2", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/ISO-HDLC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/ISO-IEC-14443-3-A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/ISO-IEC-14443-3-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/KERMIT", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/LHA", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/LJ1200", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/LTE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/M17", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/MAXIM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/MAXIM-DOW", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/MCRF4XX", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/MODBUS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/NRSC-5", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/OPENSAFETY-A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/OPENSAFETY-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/PROFIBUS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/RIELLO", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/SPI-FUJITSU", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/T10-DIF", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/TELEDISK", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/TMS37157", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/UMTS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/USB", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/V-41-LSB", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/V-41-MSB", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/VERIFONE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/X-25", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/XMODEM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/ZMODEM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-17/CAN-FD", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-21/CAN-FD", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/BLE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/FLEXRAY-A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/FLEXRAY-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/INTERLAKEN", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/LTE-A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/LTE-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/OPENPGP", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/OS-9", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-30/CDMA", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-31/PHILIPS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/AAL5", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/ADCCP", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/AIXM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/AUTOSAR", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/BASE91-C", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/BASE91-D", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/BZIP2", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/C", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/CASTAGNOLI", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/CD-ROM-EDC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/CKSUM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/D", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/DECT-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/INTERLAKEN", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/ISCSI", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/ISO-HDLC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/JAMCRC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/MEF", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/MPEG-2", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/NVME", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/PKZIP", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/POSIX", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/Q", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/SATA", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/V-42", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/XFER", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/XZ", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-40/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/ECMA-182", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/GO-ECMA", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/GO-ISO", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/MS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/NVME", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/REDIS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/WE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/XZ", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-82/DARC", + off: [1, 2, 3, 4, 5, 6] + } + ] + }, + { + name: "Width (bits)", + type: "toggleString", + value: "0", + toggleValues: ["Decimal"] + }, + { + name: "Polynomial", + type: "toggleString", + value: "0", + toggleValues: ["Hex"] + }, + { + name: "Initialization", + type: "toggleString", + value: "0", + toggleValues: ["Hex"] + }, + { + name: "Reflect input", + type: "option", + value: ["True", "False"] + }, + { + name: "Reflect output", + type: "option", + value: ["True", "False"] + }, + { + name: "Xor Output", + type: "toggleString", + value: "0", + toggleValues: ["Hex"] + } + ]; + } + + /** + * Reverse the order of bits in a number + * + * @param {BigInt} data + * @param {BigInt} reflect + */ + reflectData(data, reflect) { + let value = 0n; + for (let bit = 0n; bit < reflect; bit++) { + if ((data & 1n) === 1n) { + value |= (1n << ((reflect - 1n) - bit)); + } + data >>= 1n; + } + return value; + } + + /** + * Performs the CRC Checksum calculation bit per bit without acceleration + * + * @param {BigInt} width + * @param {ArrayBuffer} input + * @param {BigInt} poly + * @param {BigInt} remainder + * @param {boolean} reflectIn + * @param {boolean} reflectOut + * @param {BigInt} xorOut + */ + calculateCrcBitPerBit(width, input, poly, remainder, reflectIn, reflectOut, xorOut) { + const TOP_BIT = 1n << (width - 1n); + const MASK = (1n << width) - 1n; + + for (let byte of input) { + byte = BigInt(byte); + if (reflectIn) { + byte = this.reflectData(byte, 8n); + } + + for (let i = 0x80n; i !== 0n; i >>= 1n) { + let bit = remainder & TOP_BIT; + + remainder = (remainder << 1n) & MASK; + + if ((byte & i) !== 0n) { + bit ^= TOP_BIT; + } + + if (bit !== 0n) { + remainder ^= poly; + } + } + } + + if (reflectOut) { + remainder = this.reflectData(remainder, width); + } + + return remainder ^ xorOut; + } + + /** + * Generates the necessary table to speed up the calculation + * + * @param {BigInt} width + * @param {BigInt} poly + * @param {BigInt} MASK + * @param {BigInt} TOP_BIT + */ + generateTable(width, poly, MASK, TOP_BIT) { + const table = new Array(256n); + for (let byte = 0n; byte < 256n; byte++) { + let value = ((byte << width - 8n) & MASK); + for (let bit = 0n; bit < 8n; bit++) { + value = (value & TOP_BIT) === 0n ? + ((value << 1n) & MASK) : + ((value << 1n) & MASK) ^ poly; + } + table[byte] = value; + } + return table; + } + + /** + * Performs the CRC Checksum calculation byte per byte using a computed table to accelerate it + * + * @param {BigInt} width + * @param {ArrayBuffer} input + * @param {BigInt} poly + * @param {BigInt} remainder + * @param {boolean} reflectIn + * @param {boolean} reflectOut + * @param {BigInt} xorOut + */ + calculateCrcBytePerByte(width, input, poly, remainder, reflectIn, reflectOut, xorOut) { + const TOP_BIT = 1n << (width - 1n); + const MASK = (1n << width) - 1n; + const TABLE = this.generateTable(width, poly, MASK, TOP_BIT); + + for (let byte of input) { + byte = BigInt(byte); + if (reflectIn) { + byte = this.reflectData(byte, 8n); + } + remainder ^= (byte << width - 8n) & MASK; + + const INDEX = remainder >> width - 8n; + remainder = (remainder << 8n) & MASK; + remainder ^= TABLE[INDEX]; + } + + if (reflectOut) { + remainder = this.reflectData(remainder, width); + } + return remainder ^ xorOut; + } + + /** + * Calculates the CRC Checksum using Bigint (https://developer.mozilla.org/en-US/docs/Glossary/BigInt) + * + * @param {BigInt} width + * @param {ArrayBuffer} input + * @param {BigInt} poly + * @param {BigInt} init + * @param {boolean} reflectIn + * @param {boolean} reflectOut + * @param {BigInt} xorOut + */ + crc(width, input, poly, init, reflectIn, reflectOut, xorOut) { + const VALUE = width < 8n ? + this.calculateCrcBitPerBit(width, input, poly, init, reflectIn, reflectOut, xorOut) : + this.calculateCrcBytePerByte(width, input, poly, init, reflectIn, reflectOut, xorOut); + + return VALUE.toString(16).padStart(Math.ceil(Number(width) / 4), "0"); + } + + /** + * Validates user input to perform a custom CRC + * + * @param {Object} widthObject + * @param {ArrayBuffer} input + * @param {Object} polyObject + * @param {Object} initObject + * @param {Object} reflectInObject + * @param {Object} reflectOutObject + * @param {Object} xorOutObject + */ + custom(widthObject, input, polyObject, initObject, reflectInObject, reflectOutObject, xorOutObject) { + try { + const width = BigInt(widthObject.string); + const poly = BigInt("0x" + polyObject.string); + const init = BigInt("0x" + initObject.string); + const reflectIn = reflectInObject === "True"; + const reflectOut = reflectOutObject === "True"; + const xorOut = BigInt("0x" + xorOutObject.string); + + return this.crc(width, input, poly, init, reflectIn, reflectOut, xorOut); + } catch (error) { + throw new OperationError("Invalid custom CRC arguments"); + } + } + + /** + * Calculation of all known CRCs. Names and constants extracted from https://reveng.sourceforge.io/crc-catalogue/all.htm + * + * @param {ArrayBuffer} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const algorithm = args[0]; + input = new Uint8Array(input); + + switch (algorithm) { + case "Custom": return this.custom(args[1], input, args[2], args[3], args[4], args[5], args[6]); + case "CRC-3/GSM": return this.crc(3n, input, 0x3n, 0x0n, false, false, 0x7n); + case "CRC-3/ROHC": return this.crc(3n, input, 0x3n, 0x7n, true, true, 0x0n); + case "CRC-4/G-704": return this.crc(4n, input, 0x3n, 0x0n, true, true, 0x0n); + case "CRC-4/INTERLAKEN": return this.crc(4n, input, 0x3n, 0xFn, false, false, 0xFn); + case "CRC-4/ITU": return this.crc(4n, input, 0x3n, 0x0n, true, true, 0x0n); + case "CRC-5/EPC": return this.crc(5n, input, 0x09n, 0x09n, false, false, 0x00n); + case "CRC-5/EPC-C1G2": return this.crc(5n, input, 0x09n, 0x09n, false, false, 0x00n); + case "CRC-5/G-704": return this.crc(5n, input, 0x15n, 0x00n, true, true, 0x00n); + case "CRC-5/ITU": return this.crc(5n, input, 0x15n, 0x00n, true, true, 0x00n); + case "CRC-5/USB": return this.crc(5n, input, 0x05n, 0x1Fn, true, true, 0x1Fn); + case "CRC-6/CDMA2000-A": return this.crc(6n, input, 0x27n, 0x3Fn, false, false, 0x00n); + case "CRC-6/CDMA2000-B": return this.crc(6n, input, 0x07n, 0x3Fn, false, false, 0x00n); + case "CRC-6/DARC": return this.crc(6n, input, 0x19n, 0x00n, true, true, 0x00n); + case "CRC-6/G-704": return this.crc(6n, input, 0x03n, 0x00n, true, true, 0x00n); + case "CRC-6/GSM": return this.crc(6n, input, 0x2Fn, 0x00n, false, false, 0x3Fn); + case "CRC-6/ITU": return this.crc(6n, input, 0x03n, 0x00n, true, true, 0x00n); + case "CRC-7/MMC": return this.crc(7n, input, 0x09n, 0x00n, false, false, 0x00n); + case "CRC-7/ROHC": return this.crc(7n, input, 0x4Fn, 0x7Fn, true, true, 0x00n); + case "CRC-7/UMTS": return this.crc(7n, input, 0x45n, 0x00n, false, false, 0x00n); + case "CRC-8": return this.crc(8n, input, 0x07n, 0x00n, false, false, 0x00n); + case "CRC-8/8H2F": return this.crc(8n, input, 0x2Fn, 0xFFn, false, false, 0xFFn); + case "CRC-8/AES": return this.crc(8n, input, 0x1Dn, 0xFFn, true, true, 0x00n); + case "CRC-8/AUTOSAR": return this.crc(8n, input, 0x2Fn, 0xFFn, false, false, 0xFFn); + case "CRC-8/BLUETOOTH": return this.crc(8n, input, 0xA7n, 0x00n, true, true, 0x00n); + case "CRC-8/CDMA2000": return this.crc(8n, input, 0x9Bn, 0xFFn, false, false, 0x00n); + case "CRC-8/DARC": return this.crc(8n, input, 0x39n, 0x00n, true, true, 0x00n); + case "CRC-8/DVB-S2": return this.crc(8n, input, 0xD5n, 0x00n, false, false, 0x00n); + case "CRC-8/EBU": return this.crc(8n, input, 0x1Dn, 0xFFn, true, true, 0x00n); + case "CRC-8/GSM-A": return this.crc(8n, input, 0x1Dn, 0x00n, false, false, 0x00n); + case "CRC-8/GSM-B": return this.crc(8n, input, 0x49n, 0x00n, false, false, 0xFFn); + case "CRC-8/HITAG": return this.crc(8n, input, 0x1Dn, 0xFFn, false, false, 0x00n); + case "CRC-8/I-432-1": return this.crc(8n, input, 0x07n, 0x00n, false, false, 0x55n); + case "CRC-8/I-CODE": return this.crc(8n, input, 0x1Dn, 0xFDn, false, false, 0x00n); + case "CRC-8/ITU": return this.crc(8n, input, 0x07n, 0x00n, false, false, 0x55n); + case "CRC-8/LTE": return this.crc(8n, input, 0x9Bn, 0x00n, false, false, 0x00n); + case "CRC-8/MAXIM": return this.crc(8n, input, 0x31n, 0x00n, true, true, 0x00n); + case "CRC-8/MAXIM-DOW": return this.crc(8n, input, 0x31n, 0x00n, true, true, 0x00n); + case "CRC-8/MIFARE-MAD": return this.crc(8n, input, 0x1Dn, 0xC7n, false, false, 0x00n); + case "CRC-8/NRSC-5": return this.crc(8n, input, 0x31n, 0xFFn, false, false, 0x00n); + case "CRC-8/OPENSAFETY": return this.crc(8n, input, 0x2Fn, 0x00n, false, false, 0x00n); + case "CRC-8/ROHC": return this.crc(8n, input, 0x07n, 0xFFn, true, true, 0x00n); + case "CRC-8/SAE-J1850": return this.crc(8n, input, 0x1Dn, 0xFFn, false, false, 0xFFn); + case "CRC-8/SAE-J1850-ZERO": return this.crc(8n, input, 0x1Dn, 0x00n, false, false, 0x00n); + case "CRC-8/SMBUS": return this.crc(8n, input, 0x07n, 0x00n, false, false, 0x00n); + case "CRC-8/TECH-3250": return this.crc(8n, input, 0x1Dn, 0xFFn, true, true, 0x00n); + case "CRC-8/WCDMA": return this.crc(8n, input, 0x9Bn, 0x00n, true, true, 0x00n); + case "CRC-10/ATM": return this.crc(10n, input, 0x233n, 0x000n, false, false, 0x000n); + case "CRC-10/CDMA2000": return this.crc(10n, input, 0x3D9n, 0x3FFn, false, false, 0x000n); + case "CRC-10/GSM": return this.crc(10n, input, 0x175n, 0x000n, false, false, 0x3FFn); + case "CRC-10/I-610": return this.crc(10n, input, 0x233n, 0x000n, false, false, 0x000n); + case "CRC-11/FLEXRAY": return this.crc(11n, input, 0x385n, 0x01An, false, false, 0x000n); + case "CRC-11/UMTS": return this.crc(11n, input, 0x307n, 0x000n, false, false, 0x000n); + case "CRC-12/3GPP": return this.crc(12n, input, 0x80Fn, 0x000n, false, true, 0x000n); + case "CRC-12/CDMA2000": return this.crc(12n, input, 0xF13n, 0xFFFn, false, false, 0x000n); + case "CRC-12/DECT": return this.crc(12n, input, 0x80Fn, 0x000n, false, false, 0x000n); + case "CRC-12/GSM": return this.crc(12n, input, 0xD31n, 0x000n, false, false, 0xFFFn); + case "CRC-12/UMTS": return this.crc(12n, input, 0x80Fn, 0x000n, false, true, 0x000n); + case "CRC-13/BBC": return this.crc(13n, input, 0x1CF5n, 0x0000n, false, false, 0x0000n); + case "CRC-14/DARC": return this.crc(14n, input, 0x0805n, 0x0000n, true, true, 0x0000n); + case "CRC-14/GSM": return this.crc(14n, input, 0x202Dn, 0x0000n, false, false, 0x3FFFn); + case "CRC-15/CAN": return this.crc(15n, input, 0x4599n, 0x0000n, false, false, 0x0000n); + case "CRC-15/MPT1327": return this.crc(15n, input, 0x6815n, 0x0000n, false, false, 0x0001n); + case "CRC-16": return this.crc(16n, input, 0x8005n, 0x0000n, true, true, 0x0000n); + case "CRC-16/A": return this.crc(16n, input, 0x1021n, 0xC6C6n, true, true, 0x0000n); + case "CRC-16/ACORN": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0x0000n); + case "CRC-16/ARC": return this.crc(16n, input, 0x8005n, 0x0000n, true, true, 0x0000n); + case "CRC-16/AUG-CCITT": return this.crc(16n, input, 0x1021n, 0x1D0Fn, false, false, 0x0000n); + case "CRC-16/AUTOSAR": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0x0000n); + case "CRC-16/B": return this.crc(16n, input, 0x1021n, 0xFFFFn, true, true, 0xFFFFn); + case "CRC-16/BLUETOOTH": return this.crc(16n, input, 0x1021n, 0x0000n, true, true, 0x0000n); + case "CRC-16/BUYPASS": return this.crc(16n, input, 0x8005n, 0x0000n, false, false, 0x0000n); + case "CRC-16/CCITT": return this.crc(16n, input, 0x1021n, 0x0000n, true, true, 0x0000n); + case "CRC-16/CCITT-FALSE": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0x0000n); + case "CRC-16/CCITT-TRUE": return this.crc(16n, input, 0x1021n, 0x0000n, true, true, 0x0000n); + case "CRC-16/CCITT-ZERO": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0x0000n); + case "CRC-16/CDMA2000": return this.crc(16n, input, 0xC867n, 0xFFFFn, false, false, 0x0000n); + case "CRC-16/CMS": return this.crc(16n, input, 0x8005n, 0xFFFFn, false, false, 0x0000n); + case "CRC-16/DARC": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/DDS-110": return this.crc(16n, input, 0x8005n, 0x800Dn, false, false, 0x0000n); + case "CRC-16/DECT-R": return this.crc(16n, input, 0x0589n, 0x0000n, false, false, 0x0001n); + case "CRC-16/DECT-X": return this.crc(16n, input, 0x0589n, 0x0000n, false, false, 0x0000n); + case "CRC-16/DNP": return this.crc(16n, input, 0x3D65n, 0x0000n, true, true, 0xFFFFn); + case "CRC-16/EN-13757": return this.crc(16n, input, 0x3D65n, 0x0000n, false, false, 0xFFFFn); + case "CRC-16/EPC": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/EPC-C1G2": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/GENIBUS": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/GSM": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0xFFFFn); + case "CRC-16/I-CODE": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/IBM": return this.crc(16n, input, 0x8005n, 0x0000n, true, true, 0x0000n); + case "CRC-16/IBM-3740": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0x0000n); + case "CRC-16/IBM-SDLC": return this.crc(16n, input, 0x1021n, 0xFFFFn, true, true, 0xFFFFn); + case "CRC-16/IEC-61158-2": return this.crc(16n, input, 0x1DCFn, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/ISO-HDLC": return this.crc(16n, input, 0x1021n, 0xFFFFn, true, true, 0xFFFFn); + case "CRC-16/ISO-IEC-14443-3-A": return this.crc(16n, input, 0x1021n, 0xC6C6n, true, true, 0x0000n); + case "CRC-16/ISO-IEC-14443-3-B": return this.crc(16n, input, 0x1021n, 0xFFFFn, true, true, 0xFFFFn); + case "CRC-16/KERMIT": return this.crc(16n, input, 0x1021n, 0x0000n, true, true, 0x0000n); + case "CRC-16/LHA": return this.crc(16n, input, 0x8005n, 0x0000n, true, true, 0x0000n); + case "CRC-16/LJ1200": return this.crc(16n, input, 0x6F63n, 0x0000n, false, false, 0x0000n); + case "CRC-16/LTE": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0x0000n); + case "CRC-16/M17": return this.crc(16n, input, 0x5935n, 0xFFFFn, false, false, 0x0000n); + case "CRC-16/MAXIM": return this.crc(16n, input, 0x8005n, 0x0000n, true, true, 0xFFFFn); + case "CRC-16/MAXIM-DOW": return this.crc(16n, input, 0x8005n, 0x0000n, true, true, 0xFFFFn); + case "CRC-16/MCRF4XX": return this.crc(16n, input, 0x1021n, 0xFFFFn, true, true, 0x0000n); + case "CRC-16/MODBUS": return this.crc(16n, input, 0x8005n, 0xFFFFn, true, true, 0x0000n); + case "CRC-16/NRSC-5": return this.crc(16n, input, 0x080Bn, 0xFFFFn, true, true, 0x0000n); + case "CRC-16/OPENSAFETY-A": return this.crc(16n, input, 0x5935n, 0x0000n, false, false, 0x0000n); + case "CRC-16/OPENSAFETY-B": return this.crc(16n, input, 0x755Bn, 0x0000n, false, false, 0x0000n); + case "CRC-16/PROFIBUS": return this.crc(16n, input, 0x1DCFn, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/RIELLO": return this.crc(16n, input, 0x1021n, 0xB2AAn, true, true, 0x0000n); + case "CRC-16/SPI-FUJITSU": return this.crc(16n, input, 0x1021n, 0x1D0Fn, false, false, 0x0000n); + case "CRC-16/T10-DIF": return this.crc(16n, input, 0x8BB7n, 0x0000n, false, false, 0x0000n); + case "CRC-16/TELEDISK": return this.crc(16n, input, 0xA097n, 0x0000n, false, false, 0x0000n); + case "CRC-16/TMS37157": return this.crc(16n, input, 0x1021n, 0x89ECn, true, true, 0x0000n); + case "CRC-16/UMTS": return this.crc(16n, input, 0x8005n, 0x0000n, false, false, 0x0000n); + case "CRC-16/USB": return this.crc(16n, input, 0x8005n, 0xFFFFn, true, true, 0xFFFFn); + case "CRC-16/V-41-LSB": return this.crc(16n, input, 0x1021n, 0x0000n, true, true, 0x0000n); + case "CRC-16/V-41-MSB": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0x0000n); + case "CRC-16/VERIFONE": return this.crc(16n, input, 0x8005n, 0x0000n, false, false, 0x0000n); + case "CRC-16/X-25": return this.crc(16n, input, 0x1021n, 0xFFFFn, true, true, 0xFFFFn); + case "CRC-16/XMODEM": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0x0000n); + case "CRC-16/ZMODEM": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0x0000n); + case "CRC-17/CAN-FD": return this.crc(17n, input, 0x1685Bn, 0x00000n, false, false, 0x00000n); + case "CRC-21/CAN-FD": return this.crc(21n, input, 0x102899n, 0x000000n, false, false, 0x000000n); + case "CRC-24/BLE": return this.crc(24n, input, 0x00065Bn, 0x555555n, true, true, 0x000000n); + case "CRC-24/FLEXRAY-A": return this.crc(24n, input, 0x5D6DCBn, 0xFEDCBAn, false, false, 0x000000n); + case "CRC-24/FLEXRAY-B": return this.crc(24n, input, 0x5D6DCBn, 0xABCDEFn, false, false, 0x000000n); + case "CRC-24/INTERLAKEN": return this.crc(24n, input, 0x328B63n, 0xFFFFFFn, false, false, 0xFFFFFFn); + case "CRC-24/LTE-A": return this.crc(24n, input, 0x864CFBn, 0x000000n, false, false, 0x000000n); + case "CRC-24/LTE-B": return this.crc(24n, input, 0x800063n, 0x000000n, false, false, 0x000000n); + case "CRC-24/OPENPGP": return this.crc(24n, input, 0x864CFBn, 0xB704CEn, false, false, 0x000000n); + case "CRC-24/OS-9": return this.crc(24n, input, 0x800063n, 0xFFFFFFn, false, false, 0xFFFFFFn); + case "CRC-30/CDMA": return this.crc(30n, input, 0x2030B9C7n, 0x3FFFFFFFn, false, false, 0x3FFFFFFFn); + case "CRC-31/PHILIPS": return this.crc(31n, input, 0x04C11DB7n, 0x7FFFFFFFn, false, false, 0x7FFFFFFFn); + case "CRC-32": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/AAL5": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, false, false, 0xFFFFFFFFn); + case "CRC-32/ADCCP": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/AIXM": return this.crc(32n, input, 0x814141ABn, 0x00000000n, false, false, 0x00000000n); + case "CRC-32/AUTOSAR": return this.crc(32n, input, 0xF4ACFB13n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/BASE91-C": return this.crc(32n, input, 0x1EDC6F41n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/BASE91-D": return this.crc(32n, input, 0xA833982Bn, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/BZIP2": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, false, false, 0xFFFFFFFFn); + case "CRC-32/C": return this.crc(32n, input, 0x1EDC6F41n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/CASTAGNOLI": return this.crc(32n, input, 0x1EDC6F41n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/CD-ROM-EDC": return this.crc(32n, input, 0x8001801Bn, 0x00000000n, true, true, 0x00000000n); + case "CRC-32/CKSUM": return this.crc(32n, input, 0x04C11DB7n, 0x00000000n, false, false, 0xFFFFFFFFn); + case "CRC-32/D": return this.crc(32n, input, 0xA833982Bn, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/DECT-B": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, false, false, 0xFFFFFFFFn); + case "CRC-32/INTERLAKEN": return this.crc(32n, input, 0x1EDC6F41n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/ISCSI": return this.crc(32n, input, 0x1EDC6F41n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/ISO-HDLC": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/JAMCRC": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0x00000000n); + case "CRC-32/MEF": return this.crc(32n, input, 0x741B8CD7n, 0xFFFFFFFFn, true, true, 0x00000000n); + case "CRC-32/MPEG-2": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, false, false, 0x00000000n); + case "CRC-32/NVME": return this.crc(32n, input, 0x1EDC6F41n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/PKZIP": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/POSIX": return this.crc(32n, input, 0x04C11DB7n, 0x00000000n, false, false, 0xFFFFFFFFn); + case "CRC-32/Q": return this.crc(32n, input, 0x814141ABn, 0x00000000n, false, false, 0x00000000n); + case "CRC-32/SATA": return this.crc(32n, input, 0x04C11DB7n, 0x52325032n, false, false, 0x00000000n); + case "CRC-32/V-42": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/XFER": return this.crc(32n, input, 0x000000AFn, 0x00000000n, false, false, 0x00000000n); + case "CRC-32/XZ": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-40/GSM": return this.crc(40n, input, 0x0004820009n, 0x0000000000n, false, false, 0xFFFFFFFFFFn); + case "CRC-64/ECMA-182": return this.crc(64n, input, 0x42F0E1EBA9EA3693n, 0x0000000000000000n, false, false, 0x0000000000000000n); + case "CRC-64/GO-ECMA": return this.crc(64n, input, 0x42F0E1EBA9EA3693n, 0xFFFFFFFFFFFFFFFFn, true, true, 0xFFFFFFFFFFFFFFFFn); + case "CRC-64/GO-ISO": return this.crc(64n, input, 0x000000000000001Bn, 0xFFFFFFFFFFFFFFFFn, true, true, 0xFFFFFFFFFFFFFFFFn); + case "CRC-64/MS": return this.crc(64n, input, 0x259C84CBA6426349n, 0xFFFFFFFFFFFFFFFFn, true, true, 0x0000000000000000n); + case "CRC-64/NVME": return this.crc(64n, input, 0xAD93D23594C93659n, 0xFFFFFFFFFFFFFFFFn, true, true, 0xFFFFFFFFFFFFFFFFn); + case "CRC-64/REDIS": return this.crc(64n, input, 0xAD93D23594C935A9n, 0x0000000000000000n, true, true, 0x0000000000000000n); + case "CRC-64/WE": return this.crc(64n, input, 0x42F0E1EBA9EA3693n, 0xFFFFFFFFFFFFFFFFn, false, false, 0xFFFFFFFFFFFFFFFFn); + case "CRC-64/XZ": return this.crc(64n, input, 0x42F0E1EBA9EA3693n, 0xFFFFFFFFFFFFFFFFn, true, true, 0xFFFFFFFFFFFFFFFFn); + case "CRC-82/DARC": return this.crc(82n, input, 0x0308C0111011401440411n, 0x000000000000000000000n, true, true, 0x000000000000000000000n); + default: throw new OperationError("Unknown checksum algorithm"); + } + } + +} + +export default CRCChecksum; diff --git a/src/core/operations/CSSSelector.mjs b/src/core/operations/CSSSelector.mjs index d6b8da11..639726c4 100644 --- a/src/core/operations/CSSSelector.mjs +++ b/src/core/operations/CSSSelector.mjs @@ -6,7 +6,7 @@ import Operation from "../Operation.mjs"; import OperationError from "../errors/OperationError.mjs"; -import xmldom from "xmldom"; +import xmldom from "@xmldom/xmldom"; import nwmatcher from "nwmatcher"; /** diff --git a/src/core/operations/CTPH.mjs b/src/core/operations/CTPH.mjs index 7394faaa..6b6a487d 100644 --- a/src/core/operations/CTPH.mjs +++ b/src/core/operations/CTPH.mjs @@ -21,7 +21,7 @@ class CTPH extends Operation { this.name = "CTPH"; this.module = "Crypto"; this.description = "Context Triggered Piecewise Hashing, also called Fuzzy Hashing, can match inputs that have homologies. Such inputs have sequences of identical bytes in the same order, although bytes in between these sequences may be different in both content and length.
CTPH was originally based on the work of Dr. Andrew Tridgell and a spam email detector called SpamSum. This method was adapted by Jesse Kornblum and published at the DFRWS conference in 2006 in a paper 'Identifying Almost Identical Files Using Context Triggered Piecewise Hashing'."; - this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Context_Triggered_Piecewise_Hashing"; + this.infoURL = "https://forensics.wiki/context_triggered_piecewise_hashing/"; this.inputType = "string"; this.outputType = "string"; this.args = []; diff --git a/src/core/operations/CaretMdecode.mjs b/src/core/operations/CaretMdecode.mjs new file mode 100644 index 00000000..68c6dacb --- /dev/null +++ b/src/core/operations/CaretMdecode.mjs @@ -0,0 +1,98 @@ +/** + * @author tedk [tedk@ted.do] + * @copyright Crown Copyright 2024 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; + +/** + * Caret/M-decode operation + * + * https://gist.githubusercontent.com/JaHIY/3c91bbf7bea5661e6abfbd1349ee81a2/raw/c7b480e9ff24bcb8f5287a8a8a2dcb9bf5628506/decode_m_notation.cpp + */ +class CaretMdecode extends Operation { + + /** + * CaretMdecode constructor + */ + constructor() { + super(); + + this.name = "Caret/M-decode"; + this.module = "Default"; + this.description = "Decodes caret or M-encoded strings, i.e. ^M turns into a newline, M-^] turns into 0x9d. Sources such as `cat -v`.\n\nPlease be aware that when using `cat -v` ^_ (caret-underscore) will not be encoded, but represents a valid encoding (namely that of 0x1f)."; + this.infoURL = "https://en.wikipedia.org/wiki/Caret_notation"; + this.inputType = "string"; + this.outputType = "byteArray"; + this.args = []; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {byteArray} + */ + run(input, args) { + + const bytes = []; + + let prev = ""; + + for (let i = 0; i < input.length; i++) { + + const charCode = input.charCodeAt(i); + const curChar = input.charAt(i); + + if (prev === "M-^") { + if (charCode > 63 && charCode <= 95) { + bytes.push(charCode + 64); + } else if (charCode === 63) { + bytes.push(255); + } else { + bytes.push(77, 45, 94, charCode); + } + prev = ""; + } else if (prev === "M-") { + if (curChar === "^") { + prev = prev + "^"; + } else if (charCode >= 32 && charCode <= 126) { + bytes.push(charCode + 128); + prev = ""; + } else { + bytes.push(77, 45, charCode); + prev = ""; + } + } else if (prev === "M") { + if (curChar === "-") { + prev = prev + "-"; + } else { + bytes.push(77, charCode); + prev = ""; + } + } else if (prev === "^") { + if (charCode > 63 && charCode <= 126) { + bytes.push(charCode - 64); + } else if (charCode === 63) { + bytes.push(127); + } else { + bytes.push(94, charCode); + } + prev = ""; + } else { + if (curChar === "M") { + prev = "M"; + } else if (curChar === "^") { + prev = "^"; + } else { + bytes.push(charCode); + } + } + + } + return bytes; + } + +} + +export default CaretMdecode; diff --git a/src/core/operations/ChaCha.mjs b/src/core/operations/ChaCha.mjs new file mode 100644 index 00000000..2d186d35 --- /dev/null +++ b/src/core/operations/ChaCha.mjs @@ -0,0 +1,234 @@ +/** + * @author joostrijneveld [joost@joostrijneveld.nl] + * @copyright Crown Copyright 2022 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import OperationError from "../errors/OperationError.mjs"; +import Utils from "../Utils.mjs"; +import { toHex } from "../lib/Hex.mjs"; + +/** + * Computes the ChaCha block function + * + * @param {byteArray} key + * @param {byteArray} nonce + * @param {byteArray} counter + * @param {integer} rounds + * @returns {byteArray} + */ +function chacha(key, nonce, counter, rounds) { + const tau = "expand 16-byte k"; + const sigma = "expand 32-byte k"; + + let state, c; + if (key.length === 16) { + c = Utils.strToByteArray(tau); + state = c.concat(key).concat(key); + } else { + c = Utils.strToByteArray(sigma); + state = c.concat(key); + } + state = state.concat(counter).concat(nonce); + + const x = Array(); + for (let i = 0; i < 64; i += 4) { + x.push(Utils.byteArrayToInt(state.slice(i, i + 4), "little")); + } + const a = [...x]; + + /** + * Macro to compute a 32-bit rotate-left operation + * + * @param {integer} x + * @param {integer} n + * @returns {integer} + */ + function ROL32(x, n) { + return ((x << n) & 0xFFFFFFFF) | (x >>> (32 - n)); + } + + /** + * Macro to compute a single ChaCha quarterround operation + * + * @param {integer} x + * @param {integer} a + * @param {integer} b + * @param {integer} c + * @param {integer} d + * @returns {integer} + */ + function quarterround(x, a, b, c, d) { + x[a] = ((x[a] + x[b]) & 0xFFFFFFFF); x[d] = ROL32(x[d] ^ x[a], 16); + x[c] = ((x[c] + x[d]) & 0xFFFFFFFF); x[b] = ROL32(x[b] ^ x[c], 12); + x[a] = ((x[a] + x[b]) & 0xFFFFFFFF); x[d] = ROL32(x[d] ^ x[a], 8); + x[c] = ((x[c] + x[d]) & 0xFFFFFFFF); x[b] = ROL32(x[b] ^ x[c], 7); + } + + for (let i = 0; i < rounds / 2; i++) { + quarterround(x, 0, 4, 8, 12); + quarterround(x, 1, 5, 9, 13); + quarterround(x, 2, 6, 10, 14); + quarterround(x, 3, 7, 11, 15); + quarterround(x, 0, 5, 10, 15); + quarterround(x, 1, 6, 11, 12); + quarterround(x, 2, 7, 8, 13); + quarterround(x, 3, 4, 9, 14); + } + + for (let i = 0; i < 16; i++) { + x[i] = (x[i] + a[i]) & 0xFFFFFFFF; + } + + let output = Array(); + for (let i = 0; i < 16; i++) { + output = output.concat(Utils.intToByteArray(x[i], 4, "little")); + } + return output; +} + +/** + * ChaCha operation + */ +class ChaCha extends Operation { + + /** + * ChaCha constructor + */ + constructor() { + super(); + + this.name = "ChaCha"; + this.module = "Ciphers"; + this.description = "ChaCha is a stream cipher designed by Daniel J. Bernstein. It is a variant of the Salsa stream cipher. Several parameterizations exist; 'ChaCha' may refer to the original construction, or to the variant as described in RFC-8439. ChaCha is often used with Poly1305, in the ChaCha20-Poly1305 AEAD construction.
Key: ChaCha uses a key of 16 or 32 bytes (128 or 256 bits).
Nonce: ChaCha uses a nonce of 8 or 12 bytes (64 or 96 bits).
Counter: ChaCha uses a counter of 4 or 8 bytes (32 or 64 bits); together, the nonce and counter must add up to 16 bytes. The counter starts at zero at the start of the keystream, and is incremented at every 64 bytes."; + this.infoURL = "https://wikipedia.org/wiki/Salsa20#ChaCha_variant"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Nonce", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64", "Integer"] + }, + { + "name": "Counter", + "type": "number", + "value": 0, + "min": 0 + }, + { + "name": "Rounds", + "type": "option", + "value": ["20", "12", "8"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Raw", "Hex"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string, args[0].option), + nonceType = args[1].option, + rounds = parseInt(args[3], 10), + inputType = args[4], + outputType = args[5]; + + if (key.length !== 16 && key.length !== 32) { + throw new OperationError(`Invalid key length: ${key.length} bytes. + +ChaCha uses a key of 16 or 32 bytes (128 or 256 bits).`); + } + + let counter, nonce, counterLength; + if (nonceType === "Integer") { + nonce = Utils.intToByteArray(parseInt(args[1].string, 10), 12, "little"); + counterLength = 4; + } else { + nonce = Utils.convertToByteArray(args[1].string, args[1].option); + if (!(nonce.length === 12 || nonce.length === 8)) { + throw new OperationError(`Invalid nonce length: ${nonce.length} bytes. + +ChaCha uses a nonce of 8 or 12 bytes (64 or 96 bits).`); + } + counterLength = 16 - nonce.length; + } + counter = Utils.intToByteArray(args[2], counterLength, "little"); + + const output = []; + input = Utils.convertToByteArray(input, inputType); + + let counterAsInt = Utils.byteArrayToInt(counter, "little"); + for (let i = 0; i < input.length; i += 64) { + counter = Utils.intToByteArray(counterAsInt, counterLength, "little"); + const stream = chacha(key, nonce, counter, rounds); + for (let j = 0; j < 64 && i + j < input.length; j++) { + output.push(input[i + j] ^ stream[j]); + } + counterAsInt++; + } + + if (outputType === "Hex") { + return toHex(output); + } else { + return Utils.arrayBufferToStr(Uint8Array.from(output).buffer); + } + } + + /** + * Highlight ChaCha + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlight(pos, args) { + const inputType = args[4], + outputType = args[5]; + if (inputType === "Raw" && outputType === "Raw") { + return pos; + } + } + + /** + * Highlight ChaCha in reverse + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlightReverse(pos, args) { + const inputType = args[4], + outputType = args[5]; + if (inputType === "Raw" && outputType === "Raw") { + return pos; + } + } + +} + +export default ChaCha; diff --git a/src/core/operations/CompareCTPHHashes.mjs b/src/core/operations/CompareCTPHHashes.mjs index 40fec472..91956220 100644 --- a/src/core/operations/CompareCTPHHashes.mjs +++ b/src/core/operations/CompareCTPHHashes.mjs @@ -24,7 +24,7 @@ class CompareCTPHHashes extends Operation { this.name = "Compare CTPH hashes"; this.module = "Crypto"; this.description = "Compares two Context Triggered Piecewise Hashing (CTPH) fuzzy hashes to determine the similarity between them on a scale of 0 to 100."; - this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Context_Triggered_Piecewise_Hashing"; + this.infoURL = "https://forensics.wiki/context_triggered_piecewise_hashing/"; this.inputType = "string"; this.outputType = "Number"; this.args = [ diff --git a/src/core/operations/CompareSSDEEPHashes.mjs b/src/core/operations/CompareSSDEEPHashes.mjs index 806b048e..9937d7e6 100644 --- a/src/core/operations/CompareSSDEEPHashes.mjs +++ b/src/core/operations/CompareSSDEEPHashes.mjs @@ -24,7 +24,7 @@ class CompareSSDEEPHashes extends Operation { this.name = "Compare SSDEEP hashes"; this.module = "Crypto"; this.description = "Compares two SSDEEP fuzzy hashes to determine the similarity between them on a scale of 0 to 100."; - this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Ssdeep"; + this.infoURL = "https://forensics.wiki/ssdeep/"; this.inputType = "string"; this.outputType = "Number"; this.args = [ diff --git a/src/core/operations/ContainImage.mjs b/src/core/operations/ContainImage.mjs index a93d3569..0304733b 100644 --- a/src/core/operations/ContainImage.mjs +++ b/src/core/operations/ContainImage.mjs @@ -9,14 +9,18 @@ import OperationError from "../errors/OperationError.mjs"; import { isImage } from "../lib/FileType.mjs"; import { toBase64 } from "../lib/Base64.mjs"; import { isWorkerEnvironment } from "../Utils.mjs"; -import jimplib from "jimp/es/index.js"; -const jimp = jimplib.default ? jimplib.default : jimplib; +import { + Jimp, + JimpMime, + ResizeStrategy, + HorizontalAlign, + VerticalAlign, +} from "jimp"; /** * Contain Image operation */ class ContainImage extends Operation { - /** * ContainImage constructor */ @@ -25,7 +29,8 @@ class ContainImage extends Operation { this.name = "Contain Image"; this.module = "Image"; - this.description = "Scales an image to the specified width and height, maintaining the aspect ratio. The image may be letterboxed."; + this.description = + "Scales an image to the specified width and height, maintaining the aspect ratio. The image may be letterboxed."; this.infoURL = ""; this.inputType = "ArrayBuffer"; this.outputType = "ArrayBuffer"; @@ -35,33 +40,25 @@ class ContainImage extends Operation { name: "Width", type: "number", value: 100, - min: 1 + min: 1, }, { name: "Height", type: "number", value: 100, - min: 1 + min: 1, }, { name: "Horizontal align", type: "option", - value: [ - "Left", - "Center", - "Right" - ], - defaultIndex: 1 + value: ["Left", "Center", "Right"], + defaultIndex: 1, }, { name: "Vertical align", type: "option", - value: [ - "Top", - "Middle", - "Bottom" - ], - defaultIndex: 1 + value: ["Top", "Middle", "Bottom"], + defaultIndex: 1, }, { name: "Resizing algorithm", @@ -71,15 +68,15 @@ class ContainImage extends Operation { "Bilinear", "Bicubic", "Hermite", - "Bezier" + "Bezier", ], - defaultIndex: 1 + defaultIndex: 1, }, { name: "Opaque background", type: "boolean", - value: true - } + value: true, + }, ]; } @@ -92,20 +89,20 @@ class ContainImage extends Operation { const [width, height, hAlign, vAlign, alg, opaqueBg] = args; const resizeMap = { - "Nearest Neighbour": jimp.RESIZE_NEAREST_NEIGHBOR, - "Bilinear": jimp.RESIZE_BILINEAR, - "Bicubic": jimp.RESIZE_BICUBIC, - "Hermite": jimp.RESIZE_HERMITE, - "Bezier": jimp.RESIZE_BEZIER + "Nearest Neighbour": ResizeStrategy.NEAREST_NEIGHBOR, + Bilinear: ResizeStrategy.BILINEAR, + Bicubic: ResizeStrategy.BICUBIC, + Hermite: ResizeStrategy.HERMITE, + Bezier: ResizeStrategy.BEZIER, }; const alignMap = { - "Left": jimp.HORIZONTAL_ALIGN_LEFT, - "Center": jimp.HORIZONTAL_ALIGN_CENTER, - "Right": jimp.HORIZONTAL_ALIGN_RIGHT, - "Top": jimp.VERTICAL_ALIGN_TOP, - "Middle": jimp.VERTICAL_ALIGN_MIDDLE, - "Bottom": jimp.VERTICAL_ALIGN_BOTTOM + Left: HorizontalAlign.LEFT, + Center: HorizontalAlign.CENTER, + Right: HorizontalAlign.RIGHT, + Top: VerticalAlign.TOP, + Middle: VerticalAlign.MIDDLE, + Bottom: VerticalAlign.BOTTOM, }; if (!isImage(input)) { @@ -114,26 +111,39 @@ class ContainImage extends Operation { let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error loading image. (${err})`); } + const originalMime = image.mime; try { if (isWorkerEnvironment()) self.sendStatusMessage("Containing image..."); - image.contain(width, height, alignMap[hAlign] | alignMap[vAlign], resizeMap[alg]); + image.contain({ + w: width, + h: height, + align: alignMap[hAlign] | alignMap[vAlign], + mode: resizeMap[alg], + }); if (opaqueBg) { - const newImage = await jimp.read(width, height, 0x000000FF); - newImage.blit(image, 0, 0); - image = newImage; + const newImage = new Jimp({ + width, + height, + color: 0x000000ff, + }); + image = newImage.blit({ + src: image, + x: 0, + y: 0, + }); } let imageBuffer; - if (image.getMIME() === "image/gif") { - imageBuffer = await image.getBufferAsync(jimp.MIME_PNG); + if (originalMime === "image/gif") { + imageBuffer = await image.getBuffer(JimpMime.png); } else { - imageBuffer = await image.getBufferAsync(jimp.AUTO); + imageBuffer = await image.getBuffer(originalMime); } return imageBuffer.buffer; } catch (err) { @@ -157,7 +167,6 @@ class ContainImage extends Operation { return ``;
}
-
}
export default ContainImage;
diff --git a/src/core/operations/ConvertImageFormat.mjs b/src/core/operations/ConvertImageFormat.mjs
index c9923d4d..5a8cb6f4 100644
--- a/src/core/operations/ConvertImageFormat.mjs
+++ b/src/core/operations/ConvertImageFormat.mjs
@@ -8,14 +8,12 @@ import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import { Jimp, JimpMime, PNGFilterType } from "jimp";
/**
* Convert Image Format operation
*/
class ConvertImageFormat extends Operation {
-
/**
* ConvertImageFormat constructor
*/
@@ -24,7 +22,8 @@ class ConvertImageFormat extends Operation {
this.name = "Convert Image Format";
this.module = "Image";
- this.description = "Converts an image between different formats. Supported formats:
Note: GIF files are supported for input, but cannot be outputted."; + this.description = + "Converts an image between different formats. Supported formats:
Note: GIF files are supported for input, but cannot be outputted."; this.infoURL = "https://wikipedia.org/wiki/Image_file_formats"; this.inputType = "ArrayBuffer"; this.outputType = "ArrayBuffer"; @@ -33,39 +32,27 @@ class ConvertImageFormat extends Operation { { name: "Output Format", type: "option", - value: [ - "JPEG", - "PNG", - "BMP", - "TIFF" - ] + value: ["JPEG", "PNG", "BMP", "TIFF"], }, { name: "JPEG Quality", type: "number", value: 80, min: 1, - max: 100 + max: 100, }, { name: "PNG Filter Type", type: "option", - value: [ - "Auto", - "None", - "Sub", - "Up", - "Average", - "Paeth" - ] + value: ["Auto", "None", "Sub", "Up", "Average", "Paeth"], }, { name: "PNG Deflate Level", type: "number", value: 9, min: 0, - max: 9 - } + max: 9, + }, ]; } @@ -77,19 +64,19 @@ class ConvertImageFormat extends Operation { async run(input, args) { const [format, jpegQuality, pngFilterType, pngDeflateLevel] = args; const formatMap = { - "JPEG": jimp.MIME_JPEG, - "PNG": jimp.MIME_PNG, - "BMP": jimp.MIME_BMP, - "TIFF": jimp.MIME_TIFF + JPEG: JimpMime.jpeg, + PNG: JimpMime.png, + BMP: JimpMime.bmp, + TIFF: JimpMime.tiff, }; const pngFilterMap = { - "Auto": jimp.PNG_FILTER_AUTO, - "None": jimp.PNG_FILTER_NONE, - "Sub": jimp.PNG_FILTER_SUB, - "Up": jimp.PNG_FILTER_UP, - "Average": jimp.PNG_FILTER_AVERAGE, - "Paeth": jimp.PNG_FILTER_PATH + Auto: PNGFilterType.AUTO, + None: PNGFilterType.NONE, + Sub: PNGFilterType.SUB, + Up: PNGFilterType.UP, + Average: PNGFilterType.AVERAGE, + Paeth: PNGFilterType.PATH, }; const mime = formatMap[format]; @@ -99,23 +86,30 @@ class ConvertImageFormat extends Operation { } let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error opening image file. (${err})`); } try { - switch (format) { - case "JPEG": - image.quality(jpegQuality); + let buffer; + switch (mime) { + case JimpMime.jpeg: + buffer = await image.getBuffer(mime, { + quality: jpegQuality, + }); break; - case "PNG": - image.filterType(pngFilterMap[pngFilterType]); - image.deflateLevel(pngDeflateLevel); + case JimpMime.png: + buffer = await image.getBuffer(mime, { + filterType: pngFilterMap[pngFilterType], + deflateLevel: pngDeflateLevel, + }); + break; + default: + buffer = await image.getBuffer(mime); break; } - const imageBuffer = await image.getBufferAsync(mime); - return imageBuffer.buffer; + return buffer.buffer; } catch (err) { throw new OperationError(`Error converting image format. (${err})`); } @@ -138,7 +132,6 @@ class ConvertImageFormat extends Operation { return ``;
}
-
}
export default ConvertImageFormat;
diff --git a/src/core/operations/ConvertLeetSpeak.mjs b/src/core/operations/ConvertLeetSpeak.mjs
new file mode 100644
index 00000000..1a7cb2fc
--- /dev/null
+++ b/src/core/operations/ConvertLeetSpeak.mjs
@@ -0,0 +1,116 @@
+/**
+ * @author bartblaze []
+ * @copyright Crown Copyright 2025
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * Convert Leet Speak operation
+ */
+class ConvertLeetSpeak extends Operation {
+ /**
+ * ConvertLeetSpeak constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "Convert Leet Speak";
+ this.module = "Default";
+ this.description = "Converts to and from Leet Speak.";
+ this.infoURL = "https://wikipedia.org/wiki/Leet";
+ this.inputType = "string";
+ this.outputType = "string";
+ this.args = [
+ {
+ name: "Direction",
+ type: "option",
+ value: ["To Leet Speak", "From Leet Speak"],
+ defaultIndex: 0
+ }
+ ];
+ }
+
+ /**
+ * @param {string} input
+ * @param {Object[]} args
+ * @returns {string}
+ */
+ run(input, args) {
+ const direction = args[0];
+
+ if (direction === "To Leet Speak") {
+ return input.replace(/[a-z]/gi, char => {
+ const leetChar = toLeetMap[char.toLowerCase()] || char;
+ return char === char.toUpperCase() ? leetChar.toUpperCase() : leetChar;
+ });
+ } else if (direction === "From Leet Speak") {
+ return input.replace(/[48cd3f6h1jklmn0pqr57uvwxyz]/gi, char => {
+ const normalChar = fromLeetMap[char] || char;
+ return normalChar;
+ });
+ }
+ }
+}
+
+const toLeetMap = {
+ "a": "4",
+ "b": "b",
+ "c": "c",
+ "d": "d",
+ "e": "3",
+ "f": "f",
+ "g": "g",
+ "h": "h",
+ "i": "1",
+ "j": "j",
+ "k": "k",
+ "l": "l",
+ "m": "m",
+ "n": "n",
+ "o": "0",
+ "p": "p",
+ "q": "q",
+ "r": "r",
+ "s": "5",
+ "t": "7",
+ "u": "u",
+ "v": "v",
+ "w": "w",
+ "x": "x",
+ "y": "y",
+ "z": "z"
+};
+
+const fromLeetMap = {
+ "4": "a",
+ "b": "b",
+ "c": "c",
+ "d": "d",
+ "3": "e",
+ "f": "f",
+ "g": "g",
+ "h": "h",
+ "1": "i",
+ "j": "j",
+ "k": "k",
+ "l": "l",
+ "m": "m",
+ "n": "n",
+ "0": "o",
+ "p": "p",
+ "q": "q",
+ "r": "r",
+ "5": "s",
+ "7": "t",
+ "u": "u",
+ "v": "v",
+ "w": "w",
+ "x": "x",
+ "y": "y",
+ "z": "z"
+};
+
+export default ConvertLeetSpeak;
+
diff --git a/src/core/operations/CoverImage.mjs b/src/core/operations/CoverImage.mjs
index 6fae1be3..bf9a9bd1 100644
--- a/src/core/operations/CoverImage.mjs
+++ b/src/core/operations/CoverImage.mjs
@@ -9,14 +9,18 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import {
+ Jimp,
+ JimpMime,
+ ResizeStrategy,
+ HorizontalAlign,
+ VerticalAlign,
+} from "jimp";
/**
* Cover Image operation
*/
class CoverImage extends Operation {
-
/**
* CoverImage constructor
*/
@@ -25,7 +29,8 @@ class CoverImage extends Operation {
this.name = "Cover Image";
this.module = "Image";
- this.description = "Scales the image to the given width and height, keeping the aspect ratio. The image may be clipped.";
+ this.description =
+ "Scales the image to the given width and height, keeping the aspect ratio. The image may be clipped.";
this.infoURL = "";
this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer";
@@ -35,33 +40,25 @@ class CoverImage extends Operation {
name: "Width",
type: "number",
value: 100,
- min: 1
+ min: 1,
},
{
name: "Height",
type: "number",
value: 100,
- min: 1
+ min: 1,
},
{
name: "Horizontal align",
type: "option",
- value: [
- "Left",
- "Center",
- "Right"
- ],
- defaultIndex: 1
+ value: ["Left", "Center", "Right"],
+ defaultIndex: 1,
},
{
name: "Vertical align",
type: "option",
- value: [
- "Top",
- "Middle",
- "Bottom"
- ],
- defaultIndex: 1
+ value: ["Top", "Middle", "Bottom"],
+ defaultIndex: 1,
},
{
name: "Resizing algorithm",
@@ -71,10 +68,10 @@ class CoverImage extends Operation {
"Bilinear",
"Bicubic",
"Hermite",
- "Bezier"
+ "Bezier",
],
- defaultIndex: 1
- }
+ defaultIndex: 1,
+ },
];
}
@@ -87,20 +84,20 @@ class CoverImage extends Operation {
const [width, height, hAlign, vAlign, alg] = args;
const resizeMap = {
- "Nearest Neighbour": jimp.RESIZE_NEAREST_NEIGHBOR,
- "Bilinear": jimp.RESIZE_BILINEAR,
- "Bicubic": jimp.RESIZE_BICUBIC,
- "Hermite": jimp.RESIZE_HERMITE,
- "Bezier": jimp.RESIZE_BEZIER
+ "Nearest Neighbour": ResizeStrategy.NEAREST_NEIGHBOR,
+ Bilinear: ResizeStrategy.BILINEAR,
+ Bicubic: ResizeStrategy.BICUBIC,
+ Hermite: ResizeStrategy.HERMITE,
+ Bezier: ResizeStrategy.BEZIER,
};
const alignMap = {
- "Left": jimp.HORIZONTAL_ALIGN_LEFT,
- "Center": jimp.HORIZONTAL_ALIGN_CENTER,
- "Right": jimp.HORIZONTAL_ALIGN_RIGHT,
- "Top": jimp.VERTICAL_ALIGN_TOP,
- "Middle": jimp.VERTICAL_ALIGN_MIDDLE,
- "Bottom": jimp.VERTICAL_ALIGN_BOTTOM
+ Left: HorizontalAlign.LEFT,
+ Center: HorizontalAlign.CENTER,
+ Right: HorizontalAlign.RIGHT,
+ Top: VerticalAlign.TOP,
+ Middle: VerticalAlign.MIDDLE,
+ Bottom: VerticalAlign.BOTTOM,
};
if (!isImage(input)) {
@@ -109,19 +106,24 @@ class CoverImage extends Operation {
let image;
try {
- image = await jimp.read(input);
+ image = await Jimp.read(input);
} catch (err) {
throw new OperationError(`Error loading image. (${err})`);
}
try {
if (isWorkerEnvironment())
self.sendStatusMessage("Covering image...");
- image.cover(width, height, alignMap[hAlign] | alignMap[vAlign], resizeMap[alg]);
+ image.cover({
+ w: width,
+ h: height,
+ align: alignMap[hAlign] | alignMap[vAlign],
+ mode: resizeMap[alg],
+ });
let imageBuffer;
- if (image.getMIME() === "image/gif") {
- imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+ if (image.mime === "image/gif") {
+ imageBuffer = await image.getBuffer(JimpMime.png);
} else {
- imageBuffer = await image.getBufferAsync(jimp.AUTO);
+ imageBuffer = await image.getBuffer(image.mime);
}
return imageBuffer.buffer;
} catch (err) {
@@ -145,7 +147,6 @@ class CoverImage extends Operation {
return ``;
}
-
}
export default CoverImage;
diff --git a/src/core/operations/CropImage.mjs b/src/core/operations/CropImage.mjs
index a046cf38..6b5047bc 100644
--- a/src/core/operations/CropImage.mjs
+++ b/src/core/operations/CropImage.mjs
@@ -9,14 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import { Jimp, JimpMime } from "jimp";
/**
* Crop Image operation
*/
class CropImage extends Operation {
-
/**
* CropImage constructor
*/
@@ -25,7 +23,8 @@ class CropImage extends Operation {
this.name = "Crop Image";
this.module = "Image";
- this.description = "Crops an image to the specified region, or automatically crops edges.
Autocrop
Automatically crops same-colour borders from the image.
Autocrop tolerance
A percentage value for the tolerance of colour difference between pixels.
Only autocrop frames
Only crop real frames (all sides must have the same border)
Symmetric autocrop
Force autocrop to be symmetric (top/bottom and left/right are cropped by the same amount)
Autocrop keep border
The number of pixels of border to leave around the image."; + this.description = + "Crops an image to the specified region, or automatically crops edges.
Autocrop
Automatically crops same-colour borders from the image.
Autocrop tolerance
A percentage value for the tolerance of colour difference between pixels.
Only autocrop frames
Only crop real frames (all sides must have the same border)
Symmetric autocrop
Force autocrop to be symmetric (top/bottom and left/right are cropped by the same amount)
Autocrop keep border
The number of pixels of border to leave around the image."; this.infoURL = "https://wikipedia.org/wiki/Cropping_(image)"; this.inputType = "ArrayBuffer"; this.outputType = "ArrayBuffer"; @@ -35,30 +34,30 @@ class CropImage extends Operation { name: "X Position", type: "number", value: 0, - min: 0 + min: 0, }, { name: "Y Position", type: "number", value: 0, - min: 0 + min: 0, }, { name: "Width", type: "number", value: 10, - min: 1 + min: 1, }, { name: "Height", type: "number", value: 10, - min: 1 + min: 1, }, { name: "Autocrop", type: "boolean", - value: false + value: false, }, { name: "Autocrop tolerance (%)", @@ -66,24 +65,24 @@ class CropImage extends Operation { value: 0.02, min: 0, max: 100, - step: 0.01 + step: 0.01, }, { name: "Only autocrop frames", type: "boolean", - value: true + value: true, }, { name: "Symmetric autocrop", type: "boolean", - value: false + value: false, }, { name: "Autocrop keep border (px)", type: "number", value: 0, - min: 0 - } + min: 0, + }, ]; } @@ -93,14 +92,24 @@ class CropImage extends Operation { * @returns {byteArray} */ async run(input, args) { - const [xPos, yPos, width, height, autocrop, autoTolerance, autoFrames, autoSymmetric, autoBorder] = args; + const [ + xPos, + yPos, + width, + height, + autocrop, + autoTolerance, + autoFrames, + autoSymmetric, + autoBorder, + ] = args; if (!isImage(input)) { throw new OperationError("Invalid file type."); } let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error loading image. (${err})`); } @@ -109,20 +118,25 @@ class CropImage extends Operation { self.sendStatusMessage("Cropping image..."); if (autocrop) { image.autocrop({ - tolerance: (autoTolerance / 100), + tolerance: autoTolerance / 100, cropOnlyFrames: autoFrames, cropSymmetric: autoSymmetric, - leaveBorder: autoBorder + leaveBorder: autoBorder, }); } else { - image.crop(xPos, yPos, width, height); + image.crop({ + x: xPos, + y: yPos, + w: width, + h: height, + }); } let imageBuffer; - if (image.getMIME() === "image/gif") { - imageBuffer = await image.getBufferAsync(jimp.MIME_PNG); + if (image.mime === "image/gif") { + imageBuffer = await image.getBuffer(JimpMime.png); } else { - imageBuffer = await image.getBufferAsync(jimp.AUTO); + imageBuffer = await image.getBuffer(image.mime); } return imageBuffer.buffer; } catch (err) { @@ -146,7 +160,6 @@ class CropImage extends Operation { return ``;
}
-
}
export default CropImage;
diff --git a/src/core/operations/DESDecrypt.mjs b/src/core/operations/DESDecrypt.mjs
index 856aa065..4b1ab40e 100644
--- a/src/core/operations/DESDecrypt.mjs
+++ b/src/core/operations/DESDecrypt.mjs
@@ -22,7 +22,7 @@ class DESDecrypt extends Operation {
this.name = "DES Decrypt";
this.module = "Ciphers";
- this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.
Key: DES uses a key length of 8 bytes (64 bits).
Triple DES uses a key length of 24 bytes (192 bits).
IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
Padding: In CBC and ECB mode, PKCS#7 padding will be used as a default."; + this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.
Key: DES uses a key length of 8 bytes (64 bits).
IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
Padding: In CBC and ECB mode, PKCS#7 padding will be used as a default."; this.infoURL = "https://wikipedia.org/wiki/Data_Encryption_Standard"; this.inputType = "string"; this.outputType = "string"; @@ -72,8 +72,7 @@ class DESDecrypt extends Operation { if (key.length !== 8) { throw new OperationError(`Invalid key length: ${key.length} bytes -DES uses a key length of 8 bytes (64 bits). -Triple DES uses a key length of 24 bytes (192 bits).`); +DES uses a key length of 8 bytes (64 bits).`); } if (iv.length !== 8 && mode !== "ECB") { throw new OperationError(`Invalid IV length: ${iv.length} bytes diff --git a/src/core/operations/DESEncrypt.mjs b/src/core/operations/DESEncrypt.mjs index 9472abe8..28d6202a 100644 --- a/src/core/operations/DESEncrypt.mjs +++ b/src/core/operations/DESEncrypt.mjs @@ -22,7 +22,7 @@ class DESEncrypt extends Operation { this.name = "DES Encrypt"; this.module = "Ciphers"; - this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.
Key: DES uses a key length of 8 bytes (64 bits).
Triple DES uses a key length of 24 bytes (192 bits).
You can generate a password-based key using one of the KDF operations.
IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
Padding: In CBC and ECB mode, PKCS#7 padding will be used."; + this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.
Key: DES uses a key length of 8 bytes (64 bits).
You can generate a password-based key using one of the KDF operations.
IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
Padding: In CBC and ECB mode, PKCS#7 padding will be used."; this.infoURL = "https://wikipedia.org/wiki/Data_Encryption_Standard"; this.inputType = "string"; this.outputType = "string"; @@ -70,8 +70,7 @@ class DESEncrypt extends Operation { if (key.length !== 8) { throw new OperationError(`Invalid key length: ${key.length} bytes -DES uses a key length of 8 bytes (64 bits). -Triple DES uses a key length of 24 bytes (192 bits).`); +DES uses a key length of 8 bytes (64 bits).`); } if (iv.length !== 8 && mode !== "ECB") { throw new OperationError(`Invalid IV length: ${iv.length} bytes diff --git a/src/core/operations/DNSOverHTTPS.mjs b/src/core/operations/DNSOverHTTPS.mjs index 4dde2f13..87381226 100644 --- a/src/core/operations/DNSOverHTTPS.mjs +++ b/src/core/operations/DNSOverHTTPS.mjs @@ -51,10 +51,27 @@ class DNSOverHTTPS extends Operation { value: [ "A", "AAAA", - "TXT", - "MX", + "ANAME", + "CERT", + "CNAME", "DNSKEY", - "NS" + "HTTPS", + "IPSECKEY", + "LOC", + "MX", + "NS", + "OPENPGPKEY", + "PTR", + "RRSIG", + "SIG", + "SOA", + "SPF", + "SRV", + "SSHFP", + "TA", + "TXT", + "URI", + "ANY" ] }, { diff --git a/src/core/operations/DateTimeDelta.mjs b/src/core/operations/DateTimeDelta.mjs new file mode 100644 index 00000000..7f82cf01 --- /dev/null +++ b/src/core/operations/DateTimeDelta.mjs @@ -0,0 +1,107 @@ +/** + * @author tomgond [tom.gonda@gmail.com] + * @copyright Crown Copyright 2024 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import moment from "moment-timezone"; +import {DATETIME_FORMATS, FORMAT_EXAMPLES} from "../lib/DateTime.mjs"; + +/** + * DateTime Delta operation + */ +class DateTimeDelta extends Operation { + + /** + * DateTimeDelta constructor + */ + constructor() { + super(); + + this.name = "DateTime Delta"; + this.module = "Default"; + this.description = "Calculates a new DateTime value given an input DateTime value and a time difference (delta) from the input DateTime value."; + this.inputType = "string"; + this.outputType = "html"; + this.args = [ + { + "name": "Built in formats", + "type": "populateOption", + "value": DATETIME_FORMATS, + "target": 1 + }, + { + "name": "Input format string", + "type": "binaryString", + "value": "DD/MM/YYYY HH:mm:ss" + }, + { + "name": "Time Operation", + "type": "option", + "value": ["Add", "Subtract"] + }, + { + "name": "Days", + "type": "number", + "value": 0 + }, + { + "name": "Hours", + "type": "number", + "value": 0 + }, + { + "name": "Minutes", + "type": "number", + "value": 0 + }, + { + "name": "Seconds", + "type": "number", + "value": 0 + } + + ]; + } + + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const inputTimezone = "UTC"; + const inputFormat = args[1]; + const operationType = args[2]; + const daysDelta = args[3]; + const hoursDelta = args[4]; + const minutesDelta = args[5]; + const secondsDelta = args[6]; + let date = ""; + + try { + date = moment.tz(input, inputFormat, inputTimezone); + if (!date || date.format() === "Invalid date") throw Error; + } catch (err) { + return `Invalid format.\n\n${FORMAT_EXAMPLES}`; + } + let newDate; + if (operationType === "Add") { + newDate = date.add(daysDelta, "days") + .add(hoursDelta, "hours") + .add(minutesDelta, "minutes") + .add(secondsDelta, "seconds"); + + } else { + newDate = date.add(-daysDelta, "days") + .add(-hoursDelta, "hours") + .add(-minutesDelta, "minutes") + .add(-secondsDelta, "seconds"); + } + return newDate.tz(inputTimezone).format(inputFormat.replace(/[<>]/g, "")); + } +} + +export default DateTimeDelta; diff --git a/src/core/operations/DecodeText.mjs b/src/core/operations/DecodeText.mjs index 9b01b79f..0fc9d2b5 100644 --- a/src/core/operations/DecodeText.mjs +++ b/src/core/operations/DecodeText.mjs @@ -6,7 +6,7 @@ import Operation from "../Operation.mjs"; import cptable from "codepage"; -import {IO_FORMAT} from "../lib/ChrEnc.mjs"; +import {CHR_ENC_CODE_PAGES} from "../lib/ChrEnc.mjs"; /** * Decode text operation @@ -26,7 +26,7 @@ class DecodeText extends Operation { "
", "Supported charsets are:", "" + Utils.escapeHtml(diff[i].value) + "";
} else if (!showSubtraction) {
output += Utils.escapeHtml(diff[i].value);
}
diff --git a/src/core/operations/DisassembleARM.mjs b/src/core/operations/DisassembleARM.mjs
new file mode 100644
index 00000000..d8cb56da
--- /dev/null
+++ b/src/core/operations/DisassembleARM.mjs
@@ -0,0 +1,193 @@
+/**
+ * @author MedjedThomasXM
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { isWorkerEnvironment } from "../Utils.mjs";
+import cs from "@alexaltea/capstone-js/dist/capstone.min.js";
+
+/**
+ * Disassemble ARM operation
+ */
+class DisassembleARM extends Operation {
+
+ /**
+ * DisassembleARM constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "Disassemble ARM";
+ this.module = "Shellcode";
+ this.description = "Disassembles ARM machine code into assembly language.
Supports ARM (32-bit), Thumb, and ARM64 (AArch64) architectures using the Capstone disassembly framework.
Input should be in hexadecimal."; + this.infoURL = "https://wikipedia.org/wiki/ARM_architecture_family"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Architecture", + "type": "option", + "value": ["ARM (32-bit)", "ARM64 (AArch64)"] + }, + { + "name": "Mode", + "type": "option", + "value": ["ARM", "Thumb", "Thumb + Cortex-M", "ARMv8"] + }, + { + "name": "Endianness", + "type": "option", + "value": ["Little Endian", "Big Endian"] + }, + { + "name": "Starting address (hex)", + "type": "number", + "value": 0 + }, + { + "name": "Show instruction hex", + "type": "boolean", + "value": true + }, + { + "name": "Show instruction position", + "type": "boolean", + "value": true + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + async run(input, args) { + const [ + architecture, + mode, + endianness, + startAddress, + showHex, + showPosition + ] = args; + + // Remove whitespace from input + const hexInput = input.replace(/\s/g, ""); + + // Validate hex input + if (!/^[0-9a-fA-F]*$/.test(hexInput)) { + throw new OperationError("Invalid hexadecimal input. Please provide valid hex characters only."); + } + + if (hexInput.length === 0) { + return ""; + } + + if (hexInput.length % 2 !== 0) { + throw new OperationError("Invalid hexadecimal input. Length must be even."); + } + + // Convert hex string to byte array + const bytes = []; + for (let i = 0; i < hexInput.length; i += 2) { + bytes.push(parseInt(hexInput.substr(i, 2), 16)); + } + + // Determine architecture constant + let arch; + if (architecture === "ARM64 (AArch64)") { + arch = cs.ARCH_ARM64; + } else { + arch = cs.ARCH_ARM; + } + + // Determine mode constant + let modeValue = cs.MODE_LITTLE_ENDIAN; + + if (architecture === "ARM (32-bit)") { + switch (mode) { + case "ARM": + modeValue = cs.MODE_ARM; + break; + case "Thumb": + modeValue = cs.MODE_THUMB; + break; + case "Thumb + Cortex-M": + modeValue = cs.MODE_THUMB | cs.MODE_MCLASS; + break; + case "ARMv8": + modeValue = cs.MODE_ARM | cs.MODE_V8; + break; + default: + modeValue = cs.MODE_ARM; + } + } else { + // ARM64 only has one mode (ARM mode is default for ARM64) + modeValue = cs.MODE_ARM; + } + + // Add endianness + if (endianness === "Big Endian") { + modeValue |= cs.MODE_BIG_ENDIAN; + } + + if (isWorkerEnvironment()) { + self.sendStatusMessage("Disassembling..."); + } + + let disassembler; + try { + disassembler = new cs.Capstone(arch, modeValue); + } catch (e) { + throw new OperationError(`Failed to initialise Capstone disassembler: ${e}`); + } + + let instructions; + try { + instructions = disassembler.disasm(bytes, startAddress); + } catch (e) { + disassembler.close(); + // Check if it's a "no valid instructions" error (code 0 means OK but nothing decoded) + if (e && e.includes && e.includes("code 0:")) { + throw new OperationError(`No valid ${architecture} instructions found in input. The bytes may be for a different architecture or mode.`); + } + throw new OperationError(`Disassembly failed: ${e}`); + } + + // Format output + const output = []; + for (const insn of instructions) { + let line = ""; + + if (showPosition) { + // Format address as hex with 0x prefix + const addrHex = "0x" + insn.address.toString(16).padStart(8, "0"); + line += addrHex + " "; + } + + if (showHex) { + // Format instruction bytes as hex + const bytesHex = insn.bytes.map(b => b.toString(16).padStart(2, "0")).join(""); + line += bytesHex.padEnd(16, " ") + " "; + } + + line += insn.mnemonic; + if (insn.op_str) { + line += " " + insn.op_str; + } + + output.push(line); + } + + disassembler.close(); + + return output.join("\n"); + } + +} + +export default DisassembleARM; diff --git a/src/core/operations/DitherImage.mjs b/src/core/operations/DitherImage.mjs index eefa38c2..f21c1f88 100644 --- a/src/core/operations/DitherImage.mjs +++ b/src/core/operations/DitherImage.mjs @@ -9,14 +9,12 @@ import OperationError from "../errors/OperationError.mjs"; import { isImage } from "../lib/FileType.mjs"; import { toBase64 } from "../lib/Base64.mjs"; import { isWorkerEnvironment } from "../Utils.mjs"; -import jimplib from "jimp/es/index.js"; -const jimp = jimplib.default ? jimplib.default : jimplib; +import { Jimp, JimpMime } from "jimp"; /** * Image Dither operation */ class DitherImage extends Operation { - /** * DitherImage constructor */ @@ -45,24 +43,26 @@ class DitherImage extends Operation { let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error loading image. (${err})`); } try { if (isWorkerEnvironment()) self.sendStatusMessage("Applying dither to image..."); - image.dither565(); + image.dither(); let imageBuffer; - if (image.getMIME() === "image/gif") { - imageBuffer = await image.getBufferAsync(jimp.MIME_PNG); + if (image.mime === "image/gif") { + imageBuffer = await image.getBuffer(JimpMime.png); } else { - imageBuffer = await image.getBufferAsync(jimp.AUTO); + imageBuffer = await image.getBuffer(image.mime); } return imageBuffer.buffer; } catch (err) { - throw new OperationError(`Error applying dither to image. (${err})`); + throw new OperationError( + `Error applying dither to image. (${err})`, + ); } } @@ -82,7 +82,6 @@ class DitherImage extends Operation { return ``;
}
-
}
export default DitherImage;
diff --git a/src/core/operations/DropNthBytes.mjs b/src/core/operations/DropNthBytes.mjs
new file mode 100644
index 00000000..e6bac1cd
--- /dev/null
+++ b/src/core/operations/DropNthBytes.mjs
@@ -0,0 +1,79 @@
+/**
+ * @author Oshawk [oshawk@protonmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Drop nth bytes operation
+ */
+class DropNthBytes extends Operation {
+
+ /**
+ * DropNthBytes constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "Drop nth bytes";
+ this.module = "Default";
+ this.description = "Drops every nth byte starting with a given byte.";
+ this.infoURL = "";
+ this.inputType = "byteArray";
+ this.outputType = "byteArray";
+ this.args = [
+ {
+ name: "Drop every",
+ type: "number",
+ value: 4
+ },
+ {
+ name: "Starting at",
+ type: "number",
+ value: 0
+ },
+ {
+ name: "Apply to each line",
+ type: "boolean",
+ value: false
+ }
+ ];
+ }
+
+ /**
+ * @param {byteArray} input
+ * @param {Object[]} args
+ * @returns {byteArray}
+ */
+ run(input, args) {
+ const n = args[0];
+ const start = args[1];
+ const eachLine = args[2];
+
+ if (parseInt(n, 10) !== n || n <= 0) {
+ throw new OperationError("'Drop every' must be a positive integer.");
+ }
+ if (parseInt(start, 10) !== start || start < 0) {
+ throw new OperationError("'Starting at' must be a positive or zero integer.");
+ }
+
+ let offset = 0;
+ const output = [];
+ for (let i = 0; i < input.length; i++) {
+ if (eachLine && input[i] === 0x0a) {
+ output.push(0x0a);
+ offset = i + 1;
+ } else if (i - offset < start || (i - (start + offset)) % n !== 0) {
+ output.push(input[i]);
+ }
+ }
+
+ return output;
+ }
+
+}
+
+export default DropNthBytes;
diff --git a/src/core/operations/ECDSASign.mjs b/src/core/operations/ECDSASign.mjs
new file mode 100644
index 00000000..7b8f57f1
--- /dev/null
+++ b/src/core/operations/ECDSASign.mjs
@@ -0,0 +1,107 @@
+/**
+ * @author cplussharp
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { fromHex } from "../lib/Hex.mjs";
+import { toBase64 } from "../lib/Base64.mjs";
+import r from "jsrsasign";
+
+/**
+ * ECDSA Sign operation
+ */
+class ECDSASign extends Operation {
+
+ /**
+ * ECDSASign constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "ECDSA Sign";
+ this.module = "Ciphers";
+ this.description = "Sign a plaintext message with a PEM encoded EC key.";
+ this.infoURL = "https://wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm";
+ this.inputType = "string";
+ this.outputType = "string";
+ this.args = [
+ {
+ name: "ECDSA Private Key (PEM)",
+ type: "text",
+ value: "-----BEGIN EC PRIVATE KEY-----"
+ },
+ {
+ name: "Message Digest Algorithm",
+ type: "option",
+ value: [
+ "SHA-256",
+ "SHA-384",
+ "SHA-512",
+ "SHA-1",
+ "MD5"
+ ]
+ },
+ {
+ name: "Output Format",
+ type: "option",
+ value: [
+ "ASN.1 HEX",
+ "P1363 HEX",
+ "JSON Web Signature",
+ "Raw JSON"
+ ]
+ }
+ ];
+ }
+
+ /**
+ * @param {string} input
+ * @param {Object[]} args
+ * @returns {string}
+ */
+ run(input, args) {
+ const [keyPem, mdAlgo, outputFormat] = args;
+
+ if (keyPem.replace("-----BEGIN EC PRIVATE KEY-----", "").length === 0) {
+ throw new OperationError("Please enter a private key.");
+ }
+
+ const internalAlgorithmName = mdAlgo.replace("-", "") + "withECDSA";
+ const sig = new r.KJUR.crypto.Signature({ alg: internalAlgorithmName });
+ const key = r.KEYUTIL.getKey(keyPem);
+ if (key.type !== "EC") {
+ throw new OperationError("Provided key is not an EC key.");
+ }
+ if (!key.isPrivate) {
+ throw new OperationError("Provided key is not a private key.");
+ }
+ sig.init(key);
+ const signatureASN1Hex = sig.signString(input);
+
+ let result;
+ switch (outputFormat) {
+ case "ASN.1 HEX":
+ result = signatureASN1Hex;
+ break;
+ case "P1363 HEX":
+ result = r.KJUR.crypto.ECDSA.asn1SigToConcatSig(signatureASN1Hex);
+ break;
+ case "JSON Web Signature":
+ result = r.KJUR.crypto.ECDSA.asn1SigToConcatSig(signatureASN1Hex);
+ result = toBase64(fromHex(result), "A-Za-z0-9-_"); // base64url
+ break;
+ case "Raw JSON": {
+ const signatureRS = r.KJUR.crypto.ECDSA.parseSigHexInHexRS(signatureASN1Hex);
+ result = JSON.stringify(signatureRS);
+ break;
+ }
+ }
+
+ return result;
+ }
+}
+
+export default ECDSASign;
diff --git a/src/core/operations/ECDSASignatureConversion.mjs b/src/core/operations/ECDSASignatureConversion.mjs
new file mode 100644
index 00000000..3f6c6bfb
--- /dev/null
+++ b/src/core/operations/ECDSASignatureConversion.mjs
@@ -0,0 +1,146 @@
+/**
+ * @author cplussharp
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { fromBase64, toBase64 } from "../lib/Base64.mjs";
+import { fromHex, toHexFast } from "../lib/Hex.mjs";
+import r from "jsrsasign";
+
+/**
+ * ECDSA Sign operation
+ */
+class ECDSASignatureConversion extends Operation {
+
+ /**
+ * ECDSASignatureConversion constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "ECDSA Signature Conversion";
+ this.module = "Ciphers";
+ this.description = "Convert an ECDSA signature between hex, asn1 and json.";
+ this.infoURL = "https://wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm";
+ this.inputType = "string";
+ this.outputType = "string";
+ this.args = [
+ {
+ name: "Input Format",
+ type: "option",
+ value: [
+ "Auto",
+ "ASN.1 HEX",
+ "P1363 HEX",
+ "JSON Web Signature",
+ "Raw JSON"
+ ]
+ },
+ {
+ name: "Output Format",
+ type: "option",
+ value: [
+ "ASN.1 HEX",
+ "P1363 HEX",
+ "JSON Web Signature",
+ "Raw JSON"
+ ]
+ }
+ ];
+ }
+
+ /**
+ * @param {string} input
+ * @param {Object[]} args
+ * @returns {string}
+ */
+ run(input, args) {
+ let inputFormat = args[0];
+ const outputFormat = args[1];
+
+ // detect input format
+ let inputJson;
+ if (inputFormat === "Auto") {
+ try {
+ inputJson = JSON.parse(input);
+ if (typeof(inputJson) === "object") {
+ inputFormat = "Raw JSON";
+ }
+ } catch {}
+ }
+
+ if (inputFormat === "Auto") {
+ const hexRegex = /^[a-f\d]{2,}$/gi;
+ if (hexRegex.test(input)) {
+ if (input.substring(0, 2) === "30" && r.ASN1HEX.isASN1HEX(input)) {
+ inputFormat = "ASN.1 HEX";
+ } else {
+ inputFormat = "P1363 HEX";
+ }
+ }
+ }
+
+ let inputBase64;
+ if (inputFormat === "Auto") {
+ try {
+ inputBase64 = fromBase64(input, "A-Za-z0-9-_", false);
+ inputFormat = "JSON Web Signature";
+ } catch {}
+ }
+
+ // convert input to ASN.1 hex
+ let signatureASN1Hex;
+ switch (inputFormat) {
+ case "Auto":
+ throw new OperationError("Signature format could not be detected");
+ case "ASN.1 HEX":
+ signatureASN1Hex = input;
+ break;
+ case "P1363 HEX":
+ signatureASN1Hex = r.KJUR.crypto.ECDSA.concatSigToASN1Sig(input);
+ break;
+ case "JSON Web Signature":
+ if (!inputBase64) inputBase64 = fromBase64(input, "A-Za-z0-9-_");
+ signatureASN1Hex = r.KJUR.crypto.ECDSA.concatSigToASN1Sig(toHexFast(inputBase64));
+ break;
+ case "Raw JSON": {
+ if (!inputJson) inputJson = JSON.parse(input);
+ if (!inputJson.r) {
+ throw new OperationError('No "r" value in the signature JSON');
+ }
+ if (!inputJson.s) {
+ throw new OperationError('No "s" value in the signature JSON');
+ }
+ signatureASN1Hex = r.KJUR.crypto.ECDSA.hexRSSigToASN1Sig(inputJson.r, inputJson.s);
+ break;
+ }
+ }
+
+ // convert ASN.1 hex to output format
+ let result;
+ switch (outputFormat) {
+ case "ASN.1 HEX":
+ result = signatureASN1Hex;
+ break;
+ case "P1363 HEX":
+ result = r.KJUR.crypto.ECDSA.asn1SigToConcatSig(signatureASN1Hex);
+ break;
+ case "JSON Web Signature":
+ result = r.KJUR.crypto.ECDSA.asn1SigToConcatSig(signatureASN1Hex);
+ result = toBase64(fromHex(result), "A-Za-z0-9-_"); // base64url
+ break;
+ case "Raw JSON": {
+ const signatureRS = r.KJUR.crypto.ECDSA.parseSigHexInHexRS(signatureASN1Hex);
+ result = JSON.stringify(signatureRS);
+ break;
+ }
+ }
+
+ return result;
+ }
+}
+
+export default ECDSASignatureConversion;
diff --git a/src/core/operations/ECDSAVerify.mjs b/src/core/operations/ECDSAVerify.mjs
new file mode 100644
index 00000000..1f8a53ea
--- /dev/null
+++ b/src/core/operations/ECDSAVerify.mjs
@@ -0,0 +1,161 @@
+/**
+ * @author cplussharp
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { fromBase64 } from "../lib/Base64.mjs";
+import { toHexFast } from "../lib/Hex.mjs";
+import r from "jsrsasign";
+import Utils from "../Utils.mjs";
+
+/**
+ * ECDSA Verify operation
+ */
+class ECDSAVerify extends Operation {
+
+ /**
+ * ECDSAVerify constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "ECDSA Verify";
+ this.module = "Ciphers";
+ this.description = "Verify a message against a signature and a public PEM encoded EC key.";
+ this.infoURL = "https://wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm";
+ this.inputType = "string";
+ this.outputType = "string";
+ this.args = [
+ {
+ name: "Input Format",
+ type: "option",
+ value: [
+ "Auto",
+ "ASN.1 HEX",
+ "P1363 HEX",
+ "JSON Web Signature",
+ "Raw JSON"
+ ]
+ },
+ {
+ name: "Message Digest Algorithm",
+ type: "option",
+ value: [
+ "SHA-256",
+ "SHA-384",
+ "SHA-512",
+ "SHA-1",
+ "MD5"
+ ]
+ },
+ {
+ name: "ECDSA Public Key (PEM)",
+ type: "text",
+ value: "-----BEGIN PUBLIC KEY-----"
+ },
+ {
+ name: "Message",
+ type: "text",
+ value: ""
+ },
+ {
+ name: "Message format",
+ type: "option",
+ value: ["Raw", "Hex", "Base64"]
+ }
+ ];
+ }
+
+ /**
+ * @param {string} input
+ * @param {Object[]} args
+ * @returns {string}
+ */
+ run(input, args) {
+ let inputFormat = args[0];
+ const [, mdAlgo, keyPem, msg, msgFormat] = args;
+
+ if (keyPem.replace("-----BEGIN PUBLIC KEY-----", "").length === 0) {
+ throw new OperationError("Please enter a public key.");
+ }
+
+ // detect input format
+ let inputJson;
+ if (inputFormat === "Auto") {
+ try {
+ inputJson = JSON.parse(input);
+ if (typeof(inputJson) === "object") {
+ inputFormat = "Raw JSON";
+ }
+ } catch {}
+ }
+
+ if (inputFormat === "Auto") {
+ const hexRegex = /^[a-f\d]{2,}$/gi;
+ if (hexRegex.test(input)) {
+ if (input.substring(0, 2) === "30" && r.ASN1HEX.isASN1HEX(input)) {
+ inputFormat = "ASN.1 HEX";
+ } else {
+ inputFormat = "P1363 HEX";
+ }
+ }
+ }
+
+ let inputBase64;
+ if (inputFormat === "Auto") {
+ try {
+ inputBase64 = fromBase64(input, "A-Za-z0-9-_", false);
+ inputFormat = "JSON Web Signature";
+ } catch {}
+ }
+
+ // convert to ASN.1 signature
+ let signatureASN1Hex;
+ switch (inputFormat) {
+ case "Auto":
+ throw new OperationError("Signature format could not be detected");
+ case "ASN.1 HEX":
+ signatureASN1Hex = input;
+ break;
+ case "P1363 HEX":
+ signatureASN1Hex = r.KJUR.crypto.ECDSA.concatSigToASN1Sig(input);
+ break;
+ case "JSON Web Signature":
+ if (!inputBase64) inputBase64 = fromBase64(input, "A-Za-z0-9-_");
+ signatureASN1Hex = r.KJUR.crypto.ECDSA.concatSigToASN1Sig(toHexFast(inputBase64));
+ break;
+ case "Raw JSON": {
+ if (!inputJson) inputJson = JSON.parse(input);
+ if (!inputJson.r) {
+ throw new OperationError('No "r" value in the signature JSON');
+ }
+ if (!inputJson.s) {
+ throw new OperationError('No "s" value in the signature JSON');
+ }
+ signatureASN1Hex = r.KJUR.crypto.ECDSA.hexRSSigToASN1Sig(inputJson.r, inputJson.s);
+ break;
+ }
+ }
+
+ // verify signature
+ const internalAlgorithmName = mdAlgo.replace("-", "") + "withECDSA";
+ const sig = new r.KJUR.crypto.Signature({ alg: internalAlgorithmName });
+ const key = r.KEYUTIL.getKey(keyPem);
+ if (key.type !== "EC") {
+ throw new OperationError("Provided key is not an EC key.");
+ }
+ if (!key.isPublic) {
+ throw new OperationError("Provided key is not a public key.");
+ }
+ sig.init(key);
+ const messageStr = Utils.convertToByteString(msg, msgFormat);
+ sig.updateString(messageStr);
+ const result = sig.verify(signatureASN1Hex);
+ return result ? "Verified OK" : "Verification Failure";
+ }
+}
+
+export default ECDSAVerify;
diff --git a/src/core/operations/EncodeText.mjs b/src/core/operations/EncodeText.mjs
index 8fc61fce..8cc1450f 100644
--- a/src/core/operations/EncodeText.mjs
+++ b/src/core/operations/EncodeText.mjs
@@ -6,7 +6,7 @@
import Operation from "../Operation.mjs";
import cptable from "codepage";
-import {IO_FORMAT} from "../lib/ChrEnc.mjs";
+import {CHR_ENC_CODE_PAGES} from "../lib/ChrEnc.mjs";
/**
* Encode text operation
@@ -26,7 +26,7 @@ class EncodeText extends Operation {
"
", "Supported charsets are:", "
`; } diff --git a/src/core/operations/ParseEthernetFrame.mjs b/src/core/operations/ParseEthernetFrame.mjs new file mode 100644 index 00000000..0be5e1a4 --- /dev/null +++ b/src/core/operations/ParseEthernetFrame.mjs @@ -0,0 +1,112 @@ +/** + * @author tedk [tedk@ted.do] + * @copyright Crown Copyright 2024 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import OperationError from "../errors/OperationError.mjs"; +import Utils from "../Utils.mjs"; +import {fromHex, toHex} from "../lib/Hex.mjs"; + +/** + * Parse Ethernet frame operation + */ +class ParseEthernetFrame extends Operation { + + /** + * ParseEthernetFrame constructor + */ + constructor() { + super(); + + this.name = "Parse Ethernet frame"; + this.module = "Default"; + this.description = "Parses an Ethernet frame and either shows the deduced values (Source and destination MAC, VLANs) or returns the packet data.
Good for use in conjunction with the Parse IPv4, and Parse TCP/UDP recipes."; + this.infoURL = "https://en.wikipedia.org/wiki/Ethernet_frame#Frame_%E2%80%93_data_link_layer"; + this.inputType = "string"; + this.outputType = "html"; + this.args = [ + { + name: "Input type", + type: "option", + value: [ + "Raw", "Hex" + ], + defaultIndex: 0, + }, + { + name: "Return type", + type: "option", + value: [ + "Text output", "Packet data", "Packet data (hex)", + ], + defaultIndex: 0, + } + ]; + } + + + /** + * @param {string} input + * @param {Object[]} args + * @returns {html} + */ + run(input, args) { + const format = args[0]; + const outputFormat = args[1]; + + if (format === "Hex") { + input = fromHex(input); + } else if (format === "Raw") { + input = new Uint8Array(Utils.strToArrayBuffer(input)); + } else { + throw new OperationError("Invalid input format selected."); + } + + const destinationMac = input.slice(0, 6); + const sourceMac = input.slice(6, 12); + + let offset = 12; + const vlans = []; + + while (offset < input.length) { + const ethType = Utils.byteArrayToChars(input.slice(offset, offset+2)); + offset += 2; + + if (ethType === "\x81\x00" || ethType === "\x88\xA8") { + // Parse the VLAN tag: + // [0000] 0000 0000 0000 + // ^^^ PRIO - Ignored + // ^ DEI - Ignored + // ^^^^ ^^^^ ^^^^ VLAN ID + const vlanTag = input.slice(offset, offset+2); + vlans.push(((vlanTag[0] & 0b00001111) << 8) | vlanTag[1]); + + offset += 2; + } else { + break; + } + } + + const packetData = input.slice(offset); + + if (outputFormat === "Packet data") { + return Utils.byteArrayToChars(packetData); + } else if (outputFormat === "Packet data (hex)") { + return toHex(packetData); + } else if (outputFormat === "Text output") { + let retval = `Source MAC: ${toHex(sourceMac, ":")}\nDestination MAC: ${toHex(destinationMac, ":")}\n`; + if (vlans.length > 0) { + retval += `VLAN: ${vlans.join(", ")}\n`; + } + retval += `Data:\n${toHex(packetData)}`; + return retval; + } + + } + + +} + +export default ParseEthernetFrame; diff --git a/src/core/operations/ParseIPv4Header.mjs b/src/core/operations/ParseIPv4Header.mjs index 304ba0c0..4eed5d46 100644 --- a/src/core/operations/ParseIPv4Header.mjs +++ b/src/core/operations/ParseIPv4Header.mjs @@ -33,6 +33,12 @@ class ParseIPv4Header extends Operation { "name": "Input format", "type": "option", "value": ["Hex", "Raw"] + }, + { + "name": "Output format", + "type": "option", + "value": ["Table", "Data (hex)", "Data (raw)"], + defaultIndex: 0, } ]; } @@ -44,12 +50,14 @@ class ParseIPv4Header extends Operation { */ run(input, args) { const format = args[0]; + const outputFormat = args[1]; + let output; if (format === "Hex") { input = fromHex(input); } else if (format === "Raw") { - input = Utils.strToByteArray(input); + input = new Uint8Array(Utils.strToArrayBuffer(input)); } else { throw new OperationError("Unrecognised input format."); } @@ -98,7 +106,10 @@ class ParseIPv4Header extends Operation { checksumResult = givenChecksum + " (incorrect, should be " + correctChecksum + ")"; } - output = `
";
+ } else if (outputFormat === "Data (hex)") {
+ return toHex(data);
+ } else if (outputFormat === "Data (raw)") {
+ return Utils.byteArrayToChars(data);
}
-
- return output + "
";
}
}
diff --git a/src/core/operations/ParseQRCode.mjs b/src/core/operations/ParseQRCode.mjs
index 77ab7d21..89eaddee 100644
--- a/src/core/operations/ParseQRCode.mjs
+++ b/src/core/operations/ParseQRCode.mjs
@@ -13,7 +13,6 @@ import { parseQrCode } from "../lib/QRCode.mjs";
* Parse QR Code operation
*/
class ParseQRCode extends Operation {
-
/**
* ParseQRCode constructor
*/
@@ -22,24 +21,26 @@ class ParseQRCode extends Operation {
this.name = "Parse QR Code";
this.module = "Image";
- this.description = "Reads an image file and attempts to detect and read a Quick Response (QR) code from the image.
Normalise Image
Attempts to normalise the image before parsing it to improve detection of a QR code."; + this.description = + "Reads an image file and attempts to detect and read a Quick Response (QR) code from the image.
Normalise Image
Attempts to normalise the image before parsing it to improve detection of a QR code."; this.infoURL = "https://wikipedia.org/wiki/QR_code"; this.inputType = "ArrayBuffer"; this.outputType = "string"; this.args = [ { - "name": "Normalise image", - "type": "boolean", - "value": false - } + name: "Normalise image", + type: "boolean", + value: false, + }, ]; this.checks = [ { - "pattern": "^(?:\\xff\\xd8\\xff|\\x89\\x50\\x4e\\x47|\\x47\\x49\\x46|.{8}\\x57\\x45\\x42\\x50|\\x42\\x4d)", - "flags": "", - "args": [false], - "useful": true - } + pattern: + "^(?:\\xff\\xd8\\xff|\\x89\\x50\\x4e\\x47|\\x47\\x49\\x46|.{8}\\x57\\x45\\x42\\x50|\\x42\\x4d)", + flags: "", + args: [false], + useful: true, + }, ]; } @@ -54,9 +55,8 @@ class ParseQRCode extends Operation { if (!isImage(input)) { throw new OperationError("Invalid file type."); } - return await parseQrCode(input, normalise); + return parseQrCode(input, normalise); } - } export default ParseQRCode; diff --git a/src/core/operations/ParseSSHHostKey.mjs b/src/core/operations/ParseSSHHostKey.mjs index 8a3bf5da..f1a1f58c 100644 --- a/src/core/operations/ParseSSHHostKey.mjs +++ b/src/core/operations/ParseSSHHostKey.mjs @@ -23,7 +23,7 @@ class ParseSSHHostKey extends Operation { this.name = "Parse SSH Host Key"; this.module = "Default"; - this.description = "Parses a SSH host key and extracts fields from it.
The key type can be:
The key type can be:
Generates random integers within a specified range using the browser's built-in
The supported range of integers is from
", + "RAKE is a domain-independent keyword extraction algorithm in Natural Language Processing.", + "
", + "The list of stop words are from the NLTK python package", + ].join("\n"); + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + name: "Word Delimiter (Regex)", + type: "text", + value: "\\s" + }, + { + name: "Sentence Delimiter (Regex)", + type: "text", + value: "\\.\\s|\\n" + }, + { + name: "Stop Words", + type: "text", + value: "i,me,my,myself,we,our,ours,ourselves,you,you're,you've,you'll,you'd,your,yours,yourself,yourselves,he,him,his,himself,she,she's,her,hers,herself,it,it's,its,itsef,they,them,their,theirs,themselves,what,which,who,whom,this,that,that'll,these,those,am,is,are,was,were,be,been,being,have,has,had,having,do,does',did,doing,a,an,the,and,but,if,or,because,as,until,while,of,at,by,for,with,about,against,between,into,through,during,before,after,above,below,to,from,up,down,in,out,on,off,over,under,again,further,then,once,here,there,when,where,why,how,all,any,both,each,few,more,most,other,some,such,no,nor,not,only,own,same,so,than,too,very,s,t,can,will,just,don,don't,should,should've,now,d,ll,m,o,re,ve,y,ain,aren,aren't,couldn,couldn't,didn,didn't,doesn,doesn't,hadn,hadn't,hasn,hasn't,haven,haven't,isn,isn't,ma,mightn,mightn't,mustn,mustn't,needn,needn't,shan,shan't,shouldn,shouldn't,wasn,wasn't,weren,weren't,won,won't,wouldn,wouldn't" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + + // Get delimiter regexs + const wordDelim = new RegExp(args[0], "g"); + const sentDelim = new RegExp(args[1], "g"); + + // Deduplicate the stop words and add the empty string + const stopWords = args[2].toLowerCase().replace(/ /g, "").split(",").unique(); + stopWords.push(""); + + // Lower case input and remove start and ending whitespace + input = input.toLowerCase().trim(); + + // Get tokens, token count, and phrases + const tokens = []; + const wordFrequencies = []; + let phrases = []; + + // Build up list of phrases and token counts + const sentences = input.split(sentDelim); + for (const sent of sentences) { + + // Split sentence into words + const splitSent = sent.split(wordDelim); + let startIndex = 0; + + for (let i = 0; i < splitSent.length; i++) { + const token = splitSent[i]; + if (stopWords.includes(token)) { + // If token is stop word then split to create phrase + phrases.push(splitSent.slice(startIndex, i)); + startIndex = i + 1; + } else { + // If token is not a stop word add to the count of the list of words + if (tokens.includes(token)) { + wordFrequencies[tokens.indexOf(token)]+=1; + } else { + tokens.push(token); + wordFrequencies.push(1); + } + } + } + phrases.push(splitSent.slice(startIndex)); + } + + // remove empty phrases + phrases = phrases.filter(subArray => subArray.length > 0); + + // Remove duplicate phrases + phrases = phrases.unique(); + + // Generate word_degree_matrix and populate + const wordDegreeMatrix = Array(tokens.length).fill().map(() => Array(tokens.length).fill(0)); + for (const phrase of phrases) { + for (const word1 of phrase) { + for (const word2 of phrase) { + wordDegreeMatrix[tokens.indexOf(word1)][tokens.indexOf(word2)]++; + } + } + } + + // Calculate degree score for each token + const degreeScores = Array(tokens.length).fill(0); + for (let i=0; i b[0] - a[0]);
+ scores.unshift(new Array("Scores: ", "Keywords: "));
+
+ // Output works with the 'To Table' functionality already built into CC
+ return scores.map(function (score) {
+ return score.join(", ");
+ }).join("\n");
+ }
+}
+
+export default RAKE;
diff --git a/src/core/operations/RC6Decrypt.mjs b/src/core/operations/RC6Decrypt.mjs
new file mode 100644
index 00000000..3185b632
--- /dev/null
+++ b/src/core/operations/RC6Decrypt.mjs
@@ -0,0 +1,119 @@
+/**
+ * @author Medjedtxm
+ * @copyright Crown Copyright 2026
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { toHex } from "../lib/Hex.mjs";
+import { decryptRC6, getBlockSize, getDefaultRounds } from "../lib/RC6.mjs";
+
+/**
+ * RC6 Decrypt operation
+ */
+class RC6Decrypt extends Operation {
+
+ /**
+ * RC6Decrypt constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "RC6 Decrypt";
+ this.module = "Ciphers";
+ this.description = "RC6 is a symmetric key block cipher derived from RC5. It was designed by Ron Rivest, Matt Robshaw, Ray Sidney, and Yiqun Lisa Yin to meet the requirements of the AES competition, and was one of the five finalists.
RC6 is parameterised as RC6-w/r/b where w is word size in bits (any multiple of 8 from 8-256), r is the number of rounds (1-255), and b is the key length in bytes. The standard AES submission uses w=32, r=20. Common word sizes: 8, 16, 32 (standard), 64, 128.
IV: The Initialisation Vector should be 4*w/8 bytes (e.g. 16 bytes for w=32). If not entered, it will default to null bytes.
Padding: In CBC and ECB mode, the PKCS#7 padding scheme is used."; + this.infoURL = "https://wikipedia.org/wiki/RC6"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Mode", + "type": "option", + "value": ["CBC", "CFB", "OFB", "CTR", "ECB"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Raw", "Hex"] + }, + { + "name": "Padding", + "type": "option", + "value": ["PKCS5", "NO", "ZERO", "RANDOM", "BIT"] + }, + { + "name": "Word Size", + "type": "number", + "value": 32, + "min": 8, + "max": 256, + "step": 8 + }, + { + "name": "Rounds", + "type": "number", + "value": 20, + "min": 1, + "max": 255 + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string, args[0].option), + iv = Utils.convertToByteArray(args[1].string, args[1].option), + [,, mode, inputType, outputType, padding, wordSize, rounds] = args; + + // Validate word size + if (!Number.isInteger(wordSize) || wordSize < 8 || wordSize > 256 || wordSize % 8 !== 0) + throw new OperationError(`Invalid word size: ${wordSize}. Must be a multiple of 8 between 8 and 256.`); + + const blockSize = getBlockSize(wordSize); + const defaultRounds = getDefaultRounds(wordSize); + + if (iv.length !== blockSize && iv.length !== 0 && mode !== "ECB") + throw new OperationError(`Invalid IV length: ${iv.length} bytes + +RC6-${wordSize} uses an IV length of ${blockSize} bytes (${blockSize * 8} bits). +Make sure you have specified the type correctly (e.g. Hex vs UTF8).`); + + if (!Number.isInteger(rounds) || rounds < 1 || rounds > 255) + throw new OperationError(`Invalid number of rounds: ${rounds} + +Rounds must be an integer between 1 and 255. Standard for w=${wordSize} is ${defaultRounds}.`); + + // Default IV to null bytes if empty (like AES) + const actualIv = iv.length === 0 ? new Array(blockSize).fill(0) : iv; + + input = Utils.convertToByteArray(input, inputType); + const output = decryptRC6(input, key, actualIv, mode, padding, rounds, wordSize); + return outputType === "Hex" ? toHex(output, "") : Utils.byteArrayToUtf8(output); + } + +} + +export default RC6Decrypt; diff --git a/src/core/operations/RC6Encrypt.mjs b/src/core/operations/RC6Encrypt.mjs new file mode 100644 index 00000000..d5ad6d7f --- /dev/null +++ b/src/core/operations/RC6Encrypt.mjs @@ -0,0 +1,119 @@ +/** + * @author Medjedtxm + * @copyright Crown Copyright 2026 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import Utils from "../Utils.mjs"; +import OperationError from "../errors/OperationError.mjs"; +import { toHex } from "../lib/Hex.mjs"; +import { encryptRC6, getBlockSize, getDefaultRounds } from "../lib/RC6.mjs"; + +/** + * RC6 Encrypt operation + */ +class RC6Encrypt extends Operation { + + /** + * RC6Encrypt constructor + */ + constructor() { + super(); + + this.name = "RC6 Encrypt"; + this.module = "Ciphers"; + this.description = "RC6 is a symmetric key block cipher derived from RC5. It was designed by Ron Rivest, Matt Robshaw, Ray Sidney, and Yiqun Lisa Yin to meet the requirements of the AES competition, and was one of the five finalists.
RC6 is parameterised as RC6-w/r/b where w is word size in bits (any multiple of 8 from 8-256), r is the number of rounds (1-255), and b is the key length in bytes. The standard AES submission uses w=32, r=20. Common word sizes: 8, 16, 32 (standard), 64, 128.
IV: The Initialisation Vector should be 4*w/8 bytes (e.g. 16 bytes for w=32). If not entered, it will default to null bytes.
Padding: In CBC and ECB mode, the PKCS#7 padding scheme is used."; + this.infoURL = "https://wikipedia.org/wiki/RC6"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Mode", + "type": "option", + "value": ["CBC", "CFB", "OFB", "CTR", "ECB"] + }, + { + "name": "Input", + "type": "option", + "value": ["Raw", "Hex"] + }, + { + "name": "Output", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Padding", + "type": "option", + "value": ["PKCS5", "NO", "ZERO", "RANDOM", "BIT"] + }, + { + "name": "Word Size", + "type": "number", + "value": 32, + "min": 8, + "max": 256, + "step": 8 + }, + { + "name": "Rounds", + "type": "number", + "value": 20, + "min": 1, + "max": 255 + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string, args[0].option), + iv = Utils.convertToByteArray(args[1].string, args[1].option), + [,, mode, inputType, outputType, padding, wordSize, rounds] = args; + + // Validate word size + if (!Number.isInteger(wordSize) || wordSize < 8 || wordSize > 256 || wordSize % 8 !== 0) + throw new OperationError(`Invalid word size: ${wordSize}. Must be a multiple of 8 between 8 and 256.`); + + const blockSize = getBlockSize(wordSize); + const defaultRounds = getDefaultRounds(wordSize); + + if (iv.length !== blockSize && iv.length !== 0 && mode !== "ECB") + throw new OperationError(`Invalid IV length: ${iv.length} bytes + +RC6-${wordSize} uses an IV length of ${blockSize} bytes (${blockSize * 8} bits). +Make sure you have specified the type correctly (e.g. Hex vs UTF8).`); + + if (!Number.isInteger(rounds) || rounds < 1 || rounds > 255) + throw new OperationError(`Invalid number of rounds: ${rounds} + +Rounds must be an integer between 1 and 255. Standard for w=${wordSize} is ${defaultRounds}.`); + + // Default IV to null bytes if empty (like AES) + const actualIv = iv.length === 0 ? new Array(blockSize).fill(0) : iv; + + input = Utils.convertToByteArray(input, inputType); + const output = encryptRC6(input, key, actualIv, mode, padding, rounds, wordSize); + return outputType === "Hex" ? toHex(output, "") : Utils.byteArrayToUtf8(output); + } + +} + +export default RC6Encrypt; diff --git a/src/core/operations/ROT13.mjs b/src/core/operations/ROT13.mjs index 1d059565..beec94a4 100644 --- a/src/core/operations/ROT13.mjs +++ b/src/core/operations/ROT13.mjs @@ -59,15 +59,16 @@ class ROT13 extends Operation { rot13Upperacse = args[1], rotNumbers = args[2]; let amount = args[3], - chr; + amountNumbers = args[3]; if (amount) { if (amount < 0) { amount = 26 - (Math.abs(amount) % 26); + amountNumbers = 10 - (Math.abs(amountNumbers) % 10); } for (let i = 0; i < input.length; i++) { - chr = input[i]; + let chr = input[i]; if (rot13Upperacse && chr >= 65 && chr <= 90) { // Upper case chr = (chr - 65 + amount) % 26; output[i] = chr + 65; @@ -75,7 +76,7 @@ class ROT13 extends Operation { chr = (chr - 97 + amount) % 26; output[i] = chr + 97; } else if (rotNumbers && chr >= 48 && chr <= 57) { // Numbers - chr = (chr - 48 + amount) % 10; + chr = (chr - 48 + amountNumbers) % 10; output[i] = chr + 48; } } diff --git a/src/core/operations/ROT13BruteForce.mjs b/src/core/operations/ROT13BruteForce.mjs index aefe2ab7..7468ee11 100644 --- a/src/core/operations/ROT13BruteForce.mjs +++ b/src/core/operations/ROT13BruteForce.mjs @@ -86,12 +86,12 @@ class ROT13BruteForce extends Operation { } const rotatedString = Utils.byteArrayToUtf8(rotated); if (rotatedString.toLowerCase().indexOf(cribLower) >= 0) { - const rotatedStringPrintable = Utils.printable(rotatedString, false); + const rotatedStringEscaped = Utils.escapeWhitespace(rotatedString); if (printAmount) { const amountStr = "Amount = " + (" " + amount).slice(-2) + ": "; - result.push(amountStr + rotatedStringPrintable); + result.push(amountStr + rotatedStringEscaped); } else { - result.push(rotatedStringPrintable); + result.push(rotatedStringEscaped); } } } diff --git a/src/core/operations/ROT47BruteForce.mjs b/src/core/operations/ROT47BruteForce.mjs index 5f346e00..fa1e90dc 100644 --- a/src/core/operations/ROT47BruteForce.mjs +++ b/src/core/operations/ROT47BruteForce.mjs @@ -66,12 +66,12 @@ class ROT47BruteForce extends Operation { } const rotatedString = Utils.byteArrayToUtf8(rotated); if (rotatedString.toLowerCase().indexOf(cribLower) >= 0) { - const rotatedStringPrintable = Utils.printable(rotatedString, false); + const rotatedStringEscaped = Utils.escapeWhitespace(rotatedString); if (printAmount) { const amountStr = "Amount = " + (" " + amount).slice(-2) + ": "; - result.push(amountStr + rotatedStringPrintable); + result.push(amountStr + rotatedStringEscaped); } else { - result.push(rotatedStringPrintable); + result.push(rotatedStringEscaped); } } } diff --git a/src/core/operations/RSASign.mjs b/src/core/operations/RSASign.mjs index 25160f53..5091549f 100644 --- a/src/core/operations/RSASign.mjs +++ b/src/core/operations/RSASign.mjs @@ -60,7 +60,7 @@ class RSASign extends Operation { const privateKey = forge.pki.decryptRsaPrivateKey(key, password); // Generate message hash const md = MD_ALGORITHMS[mdAlgo].create(); - md.update(input, "utf8"); + md.update(input, "raw"); // Sign message hash const sig = privateKey.sign(md); return sig; diff --git a/src/core/operations/RSAVerify.mjs b/src/core/operations/RSAVerify.mjs index 89b7d81f..8160438c 100644 --- a/src/core/operations/RSAVerify.mjs +++ b/src/core/operations/RSAVerify.mjs @@ -8,6 +8,7 @@ import Operation from "../Operation.mjs"; import OperationError from "../errors/OperationError.mjs"; import forge from "node-forge"; import { MD_ALGORITHMS } from "../lib/RSA.mjs"; +import Utils from "../Utils.mjs"; /** * RSA Verify operation @@ -37,6 +38,11 @@ class RSAVerify extends Operation { type: "text", value: "" }, + { + name: "Message format", + type: "option", + value: ["Raw", "Hex", "Base64"] + }, { name: "Message Digest Algorithm", type: "option", @@ -51,7 +57,7 @@ class RSAVerify extends Operation { * @returns {string} */ run(input, args) { - const [pemKey, message, mdAlgo] = args; + const [pemKey, message, format, mdAlgo] = args; if (pemKey.replace("-----BEGIN RSA PUBLIC KEY-----", "").length === 0) { throw new OperationError("Please enter a public key."); } @@ -60,7 +66,8 @@ class RSAVerify extends Operation { const pubKey = forge.pki.publicKeyFromPem(pemKey); // Generate message digest const md = MD_ALGORITHMS[mdAlgo].create(); - md.update(message, "utf8"); + const messageStr = Utils.convertToByteString(message, format); + md.update(messageStr, "raw"); // Compare signed message digest and generated message digest const result = pubKey.verify(md.digest().bytes(), input); return result ? "Verified OK" : "Verification Failure"; diff --git a/src/core/operations/Rabbit.mjs b/src/core/operations/Rabbit.mjs new file mode 100644 index 00000000..91ff24a3 --- /dev/null +++ b/src/core/operations/Rabbit.mjs @@ -0,0 +1,247 @@ +/** + * @author mikecat + * @copyright Crown Copyright 2022 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import Utils from "../Utils.mjs"; +import { toHexFast } from "../lib/Hex.mjs"; +import OperationError from "../errors/OperationError.mjs"; + +/** + * Rabbit operation + */ +class Rabbit extends Operation { + + /** + * Rabbit constructor + */ + constructor() { + super(); + + this.name = "Rabbit"; + this.module = "Ciphers"; + this.description = "Rabbit is a high-speed stream cipher introduced in 2003 and defined in RFC 4503.
The cipher uses a 128-bit key and an optional 64-bit initialization vector (IV).
big-endian: based on RFC4503 and RFC3447
little-endian: compatible with Crypto++"; + this.infoURL = "https://wikipedia.org/wiki/Rabbit_(cipher)"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Endianness", + "type": "option", + "value": ["Big", "Little"] + }, + { + "name": "Input", + "type": "option", + "value": ["Raw", "Hex"] + }, + { + "name": "Output", + "type": "option", + "value": ["Raw", "Hex"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string, args[0].option), + iv = Utils.convertToByteArray(args[1].string, args[1].option), + endianness = args[2], + inputType = args[3], + outputType = args[4]; + + const littleEndian = endianness === "Little"; + + if (key.length !== 16) { + throw new OperationError(`Invalid key length: ${key.length} bytes (expected: 16)`); + } + if (iv.length !== 0 && iv.length !== 8) { + throw new OperationError(`Invalid IV length: ${iv.length} bytes (expected: 0 or 8)`); + } + + // Inner State + const X = new Uint32Array(8), C = new Uint32Array(8); + let b = 0; + + // Counter System + const A = [ + 0x4d34d34d, 0xd34d34d3, 0x34d34d34, 0x4d34d34d, + 0xd34d34d3, 0x34d34d34, 0x4d34d34d, 0xd34d34d3 + ]; + const counterUpdate = function() { + for (let j = 0; j < 8; j++) { + const temp = C[j] + A[j] + b; + b = (temp / ((1 << 30) * 4)) >>> 0; + C[j] = temp; + } + }; + + // Next-State Function + const g = function(u, v) { + const uv = (u + v) >>> 0; + const upper = uv >>> 16, lower = uv & 0xffff; + const upperUpper = upper * upper; + const upperLower2 = 2 * upper * lower; + const lowerLower = lower * lower; + const mswTemp = upperUpper + ((upperLower2 / (1 << 16)) >>> 0); + const lswTemp = lowerLower + (upperLower2 & 0xffff) * (1 << 16); + const msw = mswTemp + ((lswTemp / ((1 << 30) * 4)) >>> 0); + const lsw = lswTemp >>> 0; + return lsw ^ msw; + }; + const leftRotate = function(value, width) { + return (value << width) | (value >>> (32 - width)); + }; + const nextStateHelper1 = function(v0, v1, v2) { + return v0 + leftRotate(v1, 16) + leftRotate(v2, 16); + }; + const nextStateHelper2 = function(v0, v1, v2) { + return v0 + leftRotate(v1, 8) + v2; + }; + const G = new Uint32Array(8); + const nextState = function() { + for (let j = 0; j < 8; j++) { + G[j] = g(X[j], C[j]); + } + X[0] = nextStateHelper1(G[0], G[7], G[6]); + X[1] = nextStateHelper2(G[1], G[0], G[7]); + X[2] = nextStateHelper1(G[2], G[1], G[0]); + X[3] = nextStateHelper2(G[3], G[2], G[1]); + X[4] = nextStateHelper1(G[4], G[3], G[2]); + X[5] = nextStateHelper2(G[5], G[4], G[3]); + X[6] = nextStateHelper1(G[6], G[5], G[4]); + X[7] = nextStateHelper2(G[7], G[6], G[5]); + }; + + // Key Setup Scheme + const K = new Uint16Array(8); + if (littleEndian) { + for (let i = 0; i < 8; i++) { + K[i] = (key[1 + 2 * i] << 8) | key[2 * i]; + } + } else { + for (let i = 0; i < 8; i++) { + K[i] = (key[14 - 2 * i] << 8) | key[15 - 2 * i]; + } + } + for (let j = 0; j < 8; j++) { + if (j % 2 === 0) { + X[j] = (K[(j + 1) % 8] << 16) | K[j]; + C[j] = (K[(j + 4) % 8] << 16) | K[(j + 5) % 8]; + } else { + X[j] = (K[(j + 5) % 8] << 16) | K[(j + 4) % 8]; + C[j] = (K[j] << 16) | K[(j + 1) % 8]; + } + } + for (let i = 0; i < 4; i++) { + counterUpdate(); + nextState(); + } + for (let j = 0; j < 8; j++) { + C[j] = C[j] ^ X[(j + 4) % 8]; + } + + // IV Setup Scheme + if (iv.length === 8) { + const getIVValue = function(a, b, c, d) { + if (littleEndian) { + return (iv[a] << 24) | (iv[b] << 16) | + (iv[c] << 8) | iv[d]; + } else { + return (iv[7 - a] << 24) | (iv[7 - b] << 16) | + (iv[7 - c] << 8) | iv[7 - d]; + } + }; + C[0] = C[0] ^ getIVValue(3, 2, 1, 0); + C[1] = C[1] ^ getIVValue(7, 6, 3, 2); + C[2] = C[2] ^ getIVValue(7, 6, 5, 4); + C[3] = C[3] ^ getIVValue(5, 4, 1, 0); + C[4] = C[4] ^ getIVValue(3, 2, 1, 0); + C[5] = C[5] ^ getIVValue(7, 6, 3, 2); + C[6] = C[6] ^ getIVValue(7, 6, 5, 4); + C[7] = C[7] ^ getIVValue(5, 4, 1, 0); + for (let i = 0; i < 4; i++) { + counterUpdate(); + nextState(); + } + } + + // Extraction Scheme + const S = new Uint8Array(16); + const extract = function() { + let pos = 0; + const addPart = function(value) { + S[pos++] = value >>> 8; + S[pos++] = value & 0xff; + }; + counterUpdate(); + nextState(); + addPart((X[6] >>> 16) ^ (X[1] & 0xffff)); + addPart((X[6] & 0xffff) ^ (X[3] >>> 16)); + addPart((X[4] >>> 16) ^ (X[7] & 0xffff)); + addPart((X[4] & 0xffff) ^ (X[1] >>> 16)); + addPart((X[2] >>> 16) ^ (X[5] & 0xffff)); + addPart((X[2] & 0xffff) ^ (X[7] >>> 16)); + addPart((X[0] >>> 16) ^ (X[3] & 0xffff)); + addPart((X[0] & 0xffff) ^ (X[5] >>> 16)); + if (littleEndian) { + for (let i = 0, j = S.length - 1; i < j;) { + const temp = S[i]; + S[i] = S[j]; + S[j] = temp; + i++; + j--; + } + } + }; + + const data = Utils.convertToByteString(input, inputType); + const result = new Uint8Array(data.length); + for (let i = 0; i <= data.length - 16; i += 16) { + extract(); + for (let j = 0; j < 16; j++) { + result[i + j] = data.charCodeAt(i + j) ^ S[j]; + } + } + if (data.length % 16 !== 0) { + const offset = data.length - data.length % 16; + const length = data.length - offset; + extract(); + if (littleEndian) { + for (let j = 0; j < length; j++) { + result[offset + j] = data.charCodeAt(offset + j) ^ S[j]; + } + } else { + for (let j = 0; j < length; j++) { + result[offset + j] = data.charCodeAt(offset + j) ^ S[16 - length + j]; + } + } + } + if (outputType === "Hex") { + return toHexFast(result); + } + return Utils.byteArrayToChars(result); + } + +} + +export default Rabbit; diff --git a/src/core/operations/RailFenceCipherDecode.mjs b/src/core/operations/RailFenceCipherDecode.mjs index be54ee12..39795f21 100644 --- a/src/core/operations/RailFenceCipherDecode.mjs +++ b/src/core/operations/RailFenceCipherDecode.mjs @@ -72,7 +72,7 @@ class RailFenceCipherDecode extends Operation { } } - return plaintext.join("").trim(); + return plaintext.join(""); } } diff --git a/src/core/operations/RailFenceCipherEncode.mjs b/src/core/operations/RailFenceCipherEncode.mjs index 03651f85..89eddde7 100644 --- a/src/core/operations/RailFenceCipherEncode.mjs +++ b/src/core/operations/RailFenceCipherEncode.mjs @@ -66,7 +66,7 @@ class RailFenceCipherEncode extends Operation { rows[rowIdx] += plaintext[pos]; } - return rows.join("").trim(); + return rows.join(""); } } diff --git a/src/core/operations/RandomizeColourPalette.mjs b/src/core/operations/RandomizeColourPalette.mjs index 9fe53a19..186023c2 100644 --- a/src/core/operations/RandomizeColourPalette.mjs +++ b/src/core/operations/RandomizeColourPalette.mjs @@ -10,14 +10,12 @@ import Utils from "../Utils.mjs"; import { isImage } from "../lib/FileType.mjs"; import { runHash } from "../lib/Hash.mjs"; import { toBase64 } from "../lib/Base64.mjs"; -import jimplib from "jimp/es/index.js"; -const jimp = jimplib.default ? jimplib.default : jimplib; +import { Jimp } from "jimp"; /** * Randomize Colour Palette operation */ class RandomizeColourPalette extends Operation { - /** * RandomizeColourPalette constructor */ @@ -26,7 +24,8 @@ class RandomizeColourPalette extends Operation { this.name = "Randomize Colour Palette"; this.module = "Image"; - this.description = "Randomizes each colour in an image's colour palette. This can often reveal text or symbols that were previously a very similar colour to their surroundings, a technique sometimes used in Steganography."; + this.description = + "Randomizes each colour in an image's colour palette. This can often reveal text or symbols that were previously a very similar colour to their surroundings, a technique sometimes used in Steganography."; this.infoURL = "https://wikipedia.org/wiki/Indexed_color"; this.inputType = "ArrayBuffer"; this.outputType = "ArrayBuffer"; @@ -35,8 +34,8 @@ class RandomizeColourPalette extends Operation { { name: "Seed", type: "string", - value: "" - } + value: "", + }, ]; } @@ -46,23 +45,24 @@ class RandomizeColourPalette extends Operation { * @returns {ArrayBuffer} */ async run(input, args) { - if (!isImage(input)) throw new OperationError("Please enter a valid image file."); + if (!isImage(input)) + throw new OperationError("Please enter a valid image file."); - const seed = args[0] || (Math.random().toString().substr(2)), - parsedImage = await jimp.read(input), + const seed = args[0] || Math.random().toString().substr(2), + parsedImage = await Jimp.read(input), width = parsedImage.bitmap.width, height = parsedImage.bitmap.height; let rgbString, rgbHash, rgbHex; - parsedImage.scan(0, 0, width, height, function(x, y, idx) { - rgbString = this.bitmap.data.slice(idx, idx+3).join("."); + parsedImage.scan(0, 0, width, height, function (x, y, idx) { + rgbString = this.bitmap.data.slice(idx, idx + 3).join("."); rgbHash = runHash("md5", Utils.strToArrayBuffer(seed + rgbString)); rgbHex = rgbHash.substr(0, 6) + "ff"; parsedImage.setPixelColor(parseInt(rgbHex, 16), x, y); }); - const imageBuffer = await parsedImage.getBufferAsync(jimp.AUTO); + const imageBuffer = await parsedImage.getBuffer(parsedImage.mime); return new Uint8Array(imageBuffer).buffer; } @@ -78,7 +78,6 @@ class RandomizeColourPalette extends Operation { return `})
`;
}
-
}
export default RandomizeColourPalette;
diff --git a/src/core/operations/RawInflate.mjs b/src/core/operations/RawInflate.mjs
index 4555f287..f5b57bde 100644
--- a/src/core/operations/RawInflate.mjs
+++ b/src/core/operations/RawInflate.mjs
@@ -7,7 +7,6 @@
import Operation from "../Operation.mjs";
import {INFLATE_BUFFER_TYPE} from "../lib/Zlib.mjs";
import rawinflate from "zlibjs/bin/rawinflate.min.js";
-import OperationError from "../errors/OperationError.mjs";
const Zlib = rawinflate.Zlib;
@@ -83,25 +82,6 @@ class RawInflate extends Operation {
}),
result = new Uint8Array(inflate.decompress());
- // Raw Inflate sometimes messes up and returns nonsense like this:
- // ]....]....]....]....]....]....]....]....]....]....]....]....]....]...
- // e.g. Input data of [8b, 1d, dc, 44]
- // Look for the first two square brackets:
- if (result.length > 158 && result[0] === 93 && result[5] === 93) {
- // If the first two square brackets are there, check that the others
- // are also there. If they are, throw an error. If not, continue.
- let valid = false;
- for (let i = 0; i < 155; i += 5) {
- if (result[i] !== 93) {
- valid = true;
- }
- }
-
- if (!valid) {
- throw new OperationError("Error: Unable to inflate data");
- }
- }
- // This seems to be the easiest way...
return result.buffer;
}
diff --git a/src/core/operations/RegularExpression.mjs b/src/core/operations/RegularExpression.mjs
index 1d8de9c4..c3ab5b1d 100644
--- a/src/core/operations/RegularExpression.mjs
+++ b/src/core/operations/RegularExpression.mjs
@@ -7,6 +7,7 @@
import XRegExp from "xregexp";
import Operation from "../Operation.mjs";
import Utils from "../Utils.mjs";
+import { EMAIL_REGEX } from "../lib/Extract.mjs";
import OperationError from "../errors/OperationError.mjs";
/**
@@ -45,7 +46,7 @@ class RegularExpression extends Operation {
},
{
name: "Email address",
- value: "(?:[\\u00A0-\\uD7FF\\uE000-\\uFFFFa-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[\\u00A0-\\uD7FF\\uE000-\\uFFFFa-z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[\\u00A0-\\uD7FF\\uE000-\\uFFFFa-z0-9](?:[\\u00A0-\\uD7FF\\uE000-\\uFFFF-a-z0-9-]*[\\u00A0-\\uD7FF\\uE000-\\uFFFFa-z0-9])?\\.)+[\\u00A0-\\uD7FF\\uE000-\\uFFFFa-z0-9](?:[\\u00A0-\\uD7FF\\uE000-\\uFFFFa-z0-9-]*[\\u00A0-\\uD7FF\\uE000-\\uFFFFa-z0-9])?|\\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\\.){3}\\])"
+ value: EMAIL_REGEX.source // We use a different regex library, so just take the source regex string here
},
{
name: "URL",
@@ -67,6 +68,10 @@ class RegularExpression extends Operation {
name: "MAC address",
value: "[A-Fa-f\\d]{2}(?:[:-][A-Fa-f\\d]{2}){5}"
},
+ {
+ name: "UUID",
+ value: "[0-9a-fA-F]{8}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{12}"
+ },
{
name: "Date (yyyy-mm-dd)",
value: "((?:19|20)\\d\\d)[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])"
diff --git a/src/core/operations/RenderMarkdown.mjs b/src/core/operations/RenderMarkdown.mjs
index c656bf5b..20966cca 100644
--- a/src/core/operations/RenderMarkdown.mjs
+++ b/src/core/operations/RenderMarkdown.mjs
@@ -35,6 +35,11 @@ class RenderMarkdown extends Operation {
name: "Enable syntax highlighting",
type: "boolean",
value: true
+ },
+ {
+ name: "Open links in new tab.",
+ type: "boolean",
+ value: false
}
];
}
@@ -45,7 +50,7 @@ class RenderMarkdown extends Operation {
* @returns {html}
*/
run(input, args) {
- const [convertLinks, enableHighlighting] = args,
+ const [convertLinks, enableHighlighting, openLinksBlank] = args,
md = new MarkdownIt({
linkify: convertLinks,
html: false, // Explicitly disable HTML rendering
@@ -58,12 +63,38 @@ class RenderMarkdown extends Operation {
return "";
}
- }),
- rendered = md.render(input);
-
+ });
+ if (openLinksBlank) {
+ this.makeLinksOpenInNewTab(md);
+ }
+ const rendered = md.render(input);
return ``;
}
-
}
export default ResizeImage;
diff --git a/src/core/operations/Reverse.mjs b/src/core/operations/Reverse.mjs
index 895d6723..49c752a8 100644
--- a/src/core/operations/Reverse.mjs
+++ b/src/core/operations/Reverse.mjs
@@ -5,6 +5,7 @@
*/
import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
/**
* Reverse operation
@@ -26,7 +27,8 @@ class Reverse extends Operation {
{
"name": "By",
"type": "option",
- "value": ["Character", "Line"]
+ "value": ["Byte", "Character", "Line"],
+ "defaultIndex": 1
}
];
}
@@ -57,6 +59,24 @@ class Reverse extends Operation {
result.push(0x0a);
}
return result.slice(0, input.length);
+ } else if (args[0] === "Character") {
+ const inputString = Utils.byteArrayToUtf8(input);
+ let result = "";
+ for (let i = inputString.length - 1; i >= 0; i--) {
+ const c = inputString.charCodeAt(i);
+ if (i > 0 && 0xdc00 <= c && c <= 0xdfff) {
+ const c2 = inputString.charCodeAt(i - 1);
+ if (0xd800 <= c2 && c2 <= 0xdbff) {
+ // surrogates
+ result += inputString.charAt(i - 1);
+ result += inputString.charAt(i);
+ i--;
+ continue;
+ }
+ }
+ result += inputString.charAt(i);
+ }
+ return Utils.strToUtf8ByteArray(result);
} else {
return input.reverse();
}
diff --git a/src/core/operations/RisonDecode.mjs b/src/core/operations/RisonDecode.mjs
new file mode 100644
index 00000000..d4e36f80
--- /dev/null
+++ b/src/core/operations/RisonDecode.mjs
@@ -0,0 +1,57 @@
+/**
+ * @author sg5506844 [sg5506844@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import rison from "rison";
+
+/**
+ * Rison Decode operation
+ */
+class RisonDecode extends Operation {
+
+ /**
+ * RisonDecode constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "Rison Decode";
+ this.module = "Encodings";
+ this.description = "Rison, a data serialization format optimized for compactness in URIs. Rison is a slight variation of JSON that looks vastly superior after URI encoding. Rison still expresses exactly the same set of data structures as JSON, so data can be translated back and forth without loss or guesswork.";
+ this.infoURL = "https://github.com/Nanonid/rison";
+ this.inputType = "string";
+ this.outputType = "Object";
+ this.args = [
+ {
+ name: "Decode Option",
+ type: "editableOption",
+ value: ["Decode", "Decode Object", "Decode Array"]
+ },
+ ];
+ }
+
+ /**
+ * @param {string} input
+ * @param {Object[]} args
+ * @returns {Object}
+ */
+ run(input, args) {
+ const [decodeOption] = args;
+ switch (decodeOption) {
+ case "Decode":
+ return rison.decode(input);
+ case "Decode Object":
+ return rison.decode_object(input);
+ case "Decode Array":
+ return rison.decode_array(input);
+ default:
+ throw new OperationError("Invalid Decode option");
+ }
+ }
+}
+
+export default RisonDecode;
diff --git a/src/core/operations/RisonEncode.mjs b/src/core/operations/RisonEncode.mjs
new file mode 100644
index 00000000..12b13b66
--- /dev/null
+++ b/src/core/operations/RisonEncode.mjs
@@ -0,0 +1,59 @@
+/**
+ * @author sg5506844 [sg5506844@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import rison from "rison";
+
+/**
+ * Rison Encode operation
+ */
+class RisonEncode extends Operation {
+
+ /**
+ * RisonEncode constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "Rison Encode";
+ this.module = "Encodings";
+ this.description = "Rison, a data serialization format optimized for compactness in URIs. Rison is a slight variation of JSON that looks vastly superior after URI encoding. Rison still expresses exactly the same set of data structures as JSON, so data can be translated back and forth without loss or guesswork.";
+ this.infoURL = "https://github.com/Nanonid/rison";
+ this.inputType = "Object";
+ this.outputType = "string";
+ this.args = [
+ {
+ name: "Encode Option",
+ type: "option",
+ value: ["Encode", "Encode Object", "Encode Array", "Encode URI"]
+ },
+ ];
+ }
+
+ /**
+ * @param {Object} input
+ * @param {Object[]} args
+ * @returns {string}
+ */
+ run(input, args) {
+ const [encodeOption] = args;
+ switch (encodeOption) {
+ case "Encode":
+ return rison.encode(input);
+ case "Encode Object":
+ return rison.encode_object(input);
+ case "Encode Array":
+ return rison.encode_array(input);
+ case "Encode URI":
+ return rison.encode_uri(input);
+ default:
+ throw new OperationError("Invalid encode option");
+ }
+ }
+}
+
+export default RisonEncode;
diff --git a/src/core/operations/RotateImage.mjs b/src/core/operations/RotateImage.mjs
index 45a144ac..5a96ffab 100644
--- a/src/core/operations/RotateImage.mjs
+++ b/src/core/operations/RotateImage.mjs
@@ -9,14 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import { Jimp, JimpMime } from "jimp";
/**
* Rotate Image operation
*/
class RotateImage extends Operation {
-
/**
* RotateImage constructor
*/
@@ -25,7 +23,8 @@ class RotateImage extends Operation {
this.name = "Rotate Image";
this.module = "Image";
- this.description = "Rotates an image by the specified number of degrees.";
+ this.description =
+ "Rotates an image by the specified number of degrees.";
this.infoURL = "";
this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer";
@@ -34,8 +33,8 @@ class RotateImage extends Operation {
{
name: "Rotation amount (degrees)",
type: "number",
- value: 90
- }
+ value: 90,
+ },
];
}
@@ -53,7 +52,7 @@ class RotateImage extends Operation {
let image;
try {
- image = await jimp.read(input);
+ image = await Jimp.read(input);
} catch (err) {
throw new OperationError(`Error loading image. (${err})`);
}
@@ -63,10 +62,10 @@ class RotateImage extends Operation {
image.rotate(degrees);
let imageBuffer;
- if (image.getMIME() === "image/gif") {
- imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+ if (image.mime === "image/gif") {
+ imageBuffer = await image.getBuffer(JimpMime.png);
} else {
- imageBuffer = await image.getBufferAsync(jimp.AUTO);
+ imageBuffer = await image.getBuffer(image.mime);
}
return imageBuffer.buffer;
} catch (err) {
@@ -90,7 +89,6 @@ class RotateImage extends Operation {
return ``;
}
-
}
export default RotateImage;
diff --git a/src/core/operations/SIGABA.mjs b/src/core/operations/SIGABA.mjs
index 274f09f6..e3a9b82e 100644
--- a/src/core/operations/SIGABA.mjs
+++ b/src/core/operations/SIGABA.mjs
@@ -40,7 +40,7 @@ class Sigaba extends Operation {
value: false
},
{
- name: "1st cipher rotor intial value",
+ name: "1st cipher rotor initial value",
type: "option",
value: LETTERS
},
@@ -56,7 +56,7 @@ class Sigaba extends Operation {
value: false
},
{
- name: "2nd cipher rotor intial value",
+ name: "2nd cipher rotor initial value",
type: "option",
value: LETTERS
},
@@ -72,7 +72,7 @@ class Sigaba extends Operation {
value: false
},
{
- name: "3rd cipher rotor intial value",
+ name: "3rd cipher rotor initial value",
type: "option",
value: LETTERS
},
@@ -88,7 +88,7 @@ class Sigaba extends Operation {
value: false
},
{
- name: "4th cipher rotor intial value",
+ name: "4th cipher rotor initial value",
type: "option",
value: LETTERS
},
@@ -104,7 +104,7 @@ class Sigaba extends Operation {
value: false
},
{
- name: "5th cipher rotor intial value",
+ name: "5th cipher rotor initial value",
type: "option",
value: LETTERS
},
@@ -120,7 +120,7 @@ class Sigaba extends Operation {
value: false
},
{
- name: "1st control rotor intial value",
+ name: "1st control rotor initial value",
type: "option",
value: LETTERS
},
@@ -136,7 +136,7 @@ class Sigaba extends Operation {
value: false
},
{
- name: "2nd control rotor intial value",
+ name: "2nd control rotor initial value",
type: "option",
value: LETTERS
},
@@ -152,7 +152,7 @@ class Sigaba extends Operation {
value: false
},
{
- name: "3rd control rotor intial value",
+ name: "3rd control rotor initial value",
type: "option",
value: LETTERS
},
@@ -168,7 +168,7 @@ class Sigaba extends Operation {
value: false
},
{
- name: "4th control rotor intial value",
+ name: "4th control rotor initial value",
type: "option",
value: LETTERS
},
@@ -184,7 +184,7 @@ class Sigaba extends Operation {
value: false
},
{
- name: "5th control rotor intial value",
+ name: "5th control rotor initial value",
type: "option",
value: LETTERS
},
@@ -195,7 +195,7 @@ class Sigaba extends Operation {
defaultIndex: 0
},
{
- name: "1st index rotor intial value",
+ name: "1st index rotor initial value",
type: "option",
value: NUMBERS
},
@@ -206,7 +206,7 @@ class Sigaba extends Operation {
defaultIndex: 0
},
{
- name: "2nd index rotor intial value",
+ name: "2nd index rotor initial value",
type: "option",
value: NUMBERS
},
@@ -217,7 +217,7 @@ class Sigaba extends Operation {
defaultIndex: 0
},
{
- name: "3rd index rotor intial value",
+ name: "3rd index rotor initial value",
type: "option",
value: NUMBERS
},
@@ -228,7 +228,7 @@ class Sigaba extends Operation {
defaultIndex: 0
},
{
- name: "4th index rotor intial value",
+ name: "4th index rotor initial value",
type: "option",
value: NUMBERS
},
@@ -239,7 +239,7 @@ class Sigaba extends Operation {
defaultIndex: 0
},
{
- name: "5th index rotor intial value",
+ name: "5th index rotor initial value",
type: "option",
value: NUMBERS
},
diff --git a/src/core/operations/SM2Decrypt.mjs b/src/core/operations/SM2Decrypt.mjs
new file mode 100644
index 00000000..39657110
--- /dev/null
+++ b/src/core/operations/SM2Decrypt.mjs
@@ -0,0 +1,71 @@
+/**
+ * @author flakjacket95 [dflack95@gmail.com]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import OperationError from "../errors/OperationError.mjs";
+import Operation from "../Operation.mjs";
+
+import { SM2 } from "../lib/SM2.mjs";
+
+/**
+ * SM2Decrypt operation
+ */
+class SM2Decrypt extends Operation {
+
+ /**
+ * SM2Decrypt constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "SM2 Decrypt";
+ this.module = "Crypto";
+ this.description = "Decrypts a message utilizing the SM2 standard";
+ this.infoURL = ""; // Usually a Wikipedia link. Remember to remove localisation (i.e. https://wikipedia.org/etc rather than https://en.wikipedia.org/etc)
+ this.inputType = "string";
+ this.outputType = "ArrayBuffer";
+ this.args = [
+ {
+ name: "Private Key",
+ type: "string",
+ value: "DEADBEEF"
+ },
+ {
+ "name": "Input Format",
+ "type": "option",
+ "value": ["C1C3C2", "C1C2C3"],
+ "defaultIndex": 0
+ },
+ {
+ name: "Curve",
+ type: "option",
+ "value": ["sm2p256v1"],
+ "defaultIndex": 0
+ }
+ ];
+ }
+
+ /**
+ * @param {string} input
+ * @param {Object[]} args
+ * @returns {ArrayBuffer}
+ */
+ run(input, args) {
+ const [privateKey, inputFormat, curveName] = args;
+
+ if (privateKey.length !== 64) {
+ throw new OperationError("Input private key must be in hex; and should be 32 bytes");
+ }
+
+ const sm2 = new SM2(curveName, inputFormat);
+ sm2.setPrivateKey(privateKey);
+
+ const result = sm2.decrypt(input);
+ return result;
+ }
+
+}
+
+export default SM2Decrypt;
diff --git a/src/core/operations/SM2Encrypt.mjs b/src/core/operations/SM2Encrypt.mjs
new file mode 100644
index 00000000..b1e5f901
--- /dev/null
+++ b/src/core/operations/SM2Encrypt.mjs
@@ -0,0 +1,77 @@
+/**
+ * @author flakjacket95 [dflack95@gmail.com]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import OperationError from "../errors/OperationError.mjs";
+import Operation from "../Operation.mjs";
+
+import { SM2 } from "../lib/SM2.mjs";
+
+/**
+ * SM2 Encrypt operation
+ */
+class SM2Encrypt extends Operation {
+
+ /**
+ * SM2Encrypt constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "SM2 Encrypt";
+ this.module = "Crypto";
+ this.description = "Encrypts a message utilizing the SM2 standard";
+ this.infoURL = ""; // Usually a Wikipedia link. Remember to remove localisation (i.e. https://wikipedia.org/etc rather than https://en.wikipedia.org/etc)
+ this.inputType = "ArrayBuffer";
+ this.outputType = "string";
+
+ this.args = [
+ {
+ name: "Public Key X",
+ type: "string",
+ value: "DEADBEEF"
+ },
+ {
+ name: "Public Key Y",
+ type: "string",
+ value: "DEADBEEF"
+ },
+ {
+ "name": "Output Format",
+ "type": "option",
+ "value": ["C1C3C2", "C1C2C3"],
+ "defaultIndex": 0
+ },
+ {
+ name: "Curve",
+ type: "option",
+ "value": ["sm2p256v1"],
+ "defaultIndex": 0
+ }
+ ];
+ }
+
+ /**
+ * @param {ArrayBuffer} input
+ * @param {Object[]} args
+ * @returns {byteArray}
+ */
+ run(input, args) {
+ const [publicKeyX, publicKeyY, outputFormat, curveName] = args;
+ this.outputFormat = outputFormat;
+
+ if (publicKeyX.length !== 64 || publicKeyY.length !== 64) {
+ throw new OperationError("Invalid Public Key - Ensure each component is 32 bytes in size and in hex");
+ }
+
+ const sm2 = new SM2(curveName, outputFormat);
+ sm2.setPublicKey(publicKeyX, publicKeyY);
+
+ const result = sm2.encrypt(new Uint8Array(input));
+ return result;
+ }
+}
+
+export default SM2Encrypt;
diff --git a/src/core/operations/SQLBeautify.mjs b/src/core/operations/SQLBeautify.mjs
index 0f3d2e3c..2171f7fc 100644
--- a/src/core/operations/SQLBeautify.mjs
+++ b/src/core/operations/SQLBeautify.mjs
@@ -3,8 +3,7 @@
* @copyright Crown Copyright 2016
* @license Apache-2.0
*/
-
-import vkbeautify from "vkbeautify";
+import { format } from "sql-formatter";
import Operation from "../Operation.mjs";
/**
@@ -39,7 +38,26 @@ class SQLBeautify extends Operation {
*/
run(input, args) {
const indentStr = args[0];
- return vkbeautify.sql(input, indentStr);
+ // Extract and replace bind variables like :Bind1 with __BIND_0__
+ const bindRegex = /:\w+/g;
+ const bindMap = {};
+ let bindCounter=0;
+ const placeholderInput = input.replace(bindRegex, (match) => {
+ const placeholder = `__BIND_${bindCounter++}__`;
+ bindMap[placeholder] = match;
+ return placeholder;
+ });
+ // Format the SQL with chosen options
+ let formatted= format(placeholderInput, {
+ language: "mysql", // Use MySQL as the default dialect for better compatibility with real-world SQL
+ useTabs: indentStr==="\t", // true if tab, false if spaces
+ tabWidth: indentStr.length || 4, // fallback if empty
+ indentStyle: "standard" // fine for most SQL
+ });
+ // Replace placeholders back with original bind variables
+ formatted = formatted.replace(/__BIND_\d+__/g, match => bindMap[match] || match);
+
+ return formatted;
}
}
diff --git a/src/core/operations/SSDEEP.mjs b/src/core/operations/SSDEEP.mjs
index df1557d5..6a76a68b 100644
--- a/src/core/operations/SSDEEP.mjs
+++ b/src/core/operations/SSDEEP.mjs
@@ -21,7 +21,7 @@ class SSDEEP extends Operation {
this.name = "SSDEEP";
this.module = "Crypto";
this.description = "SSDEEP is a program for computing context triggered piecewise hashes (CTPH). Also called fuzzy hashes, CTPH can match inputs that have homologies. Such inputs have sequences of identical bytes in the same order, although bytes in between these sequences may be different in both content and length.
SSDEEP hashes are now widely used for simple identification purposes (e.g. the 'Basic Properties' section in VirusTotal). Although 'better' fuzzy hashes are available, SSDEEP is still one of the primary choices because of its speed and being a de facto standard.
This operation is fundamentally the same as the CTPH operation, however their outputs differ in format."; - this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Ssdeep"; + this.infoURL = "https://forensics.wiki/ssdeep"; this.inputType = "string"; this.outputType = "string"; this.args = []; diff --git a/src/core/operations/Salsa20.mjs b/src/core/operations/Salsa20.mjs new file mode 100644 index 00000000..7a76cf26 --- /dev/null +++ b/src/core/operations/Salsa20.mjs @@ -0,0 +1,154 @@ +/** + * @author joostrijneveld [joost@joostrijneveld.nl] + * @copyright Crown Copyright 2024 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import OperationError from "../errors/OperationError.mjs"; +import Utils from "../Utils.mjs"; +import { toHex } from "../lib/Hex.mjs"; +import { salsa20Block } from "../lib/Salsa20.mjs"; + +/** + * Salsa20 operation + */ +class Salsa20 extends Operation { + + /** + * Salsa20 constructor + */ + constructor() { + super(); + + this.name = "Salsa20"; + this.module = "Ciphers"; + this.description = "Salsa20 is a stream cipher designed by Daniel J. Bernstein and submitted to the eSTREAM project; Salsa20/8 and Salsa20/12 are round-reduced variants. It is closely related to the ChaCha stream cipher.
Key: Salsa20 uses a key of 16 or 32 bytes (128 or 256 bits).
Nonce: Salsa20 uses a nonce of 8 bytes (64 bits).
Counter: Salsa uses a counter of 8 bytes (64 bits). The counter starts at zero at the start of the keystream, and is incremented at every 64 bytes."; + this.infoURL = "https://wikipedia.org/wiki/Salsa20"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Nonce", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64", "Integer"] + }, + { + "name": "Counter", + "type": "number", + "value": 0, + "min": 0 + }, + { + "name": "Rounds", + "type": "option", + "value": ["20", "12", "8"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Raw", "Hex"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string, args[0].option), + nonceType = args[1].option, + rounds = parseInt(args[3], 10), + inputType = args[4], + outputType = args[5]; + + if (key.length !== 16 && key.length !== 32) { + throw new OperationError(`Invalid key length: ${key.length} bytes. + +Salsa20 uses a key of 16 or 32 bytes (128 or 256 bits).`); + } + + let counter, nonce; + if (nonceType === "Integer") { + nonce = Utils.intToByteArray(parseInt(args[1].string, 10), 8, "little"); + } else { + nonce = Utils.convertToByteArray(args[1].string, args[1].option); + if (!(nonce.length === 8)) { + throw new OperationError(`Invalid nonce length: ${nonce.length} bytes. + +Salsa20 uses a nonce of 8 bytes (64 bits).`); + } + } + counter = Utils.intToByteArray(args[2], 8, "little"); + + const output = []; + input = Utils.convertToByteArray(input, inputType); + + let counterAsInt = Utils.byteArrayToInt(counter, "little"); + for (let i = 0; i < input.length; i += 64) { + counter = Utils.intToByteArray(counterAsInt, 8, "little"); + const stream = salsa20Block(key, nonce, counter, rounds); + for (let j = 0; j < 64 && i + j < input.length; j++) { + output.push(input[i + j] ^ stream[j]); + } + counterAsInt++; + } + + if (outputType === "Hex") { + return toHex(output); + } else { + return Utils.arrayBufferToStr(Uint8Array.from(output).buffer); + } + } + + /** + * Highlight Salsa20 + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlight(pos, args) { + const inputType = args[4], + outputType = args[5]; + if (inputType === "Raw" && outputType === "Raw") { + return pos; + } + } + + /** + * Highlight Salsa20 in reverse + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlightReverse(pos, args) { + const inputType = args[4], + outputType = args[5]; + if (inputType === "Raw" && outputType === "Raw") { + return pos; + } + } + +} + +export default Salsa20; diff --git a/src/core/operations/ScanForEmbeddedFiles.mjs b/src/core/operations/ScanForEmbeddedFiles.mjs index 411b4c1d..2e83fcb9 100644 --- a/src/core/operations/ScanForEmbeddedFiles.mjs +++ b/src/core/operations/ScanForEmbeddedFiles.mjs @@ -60,7 +60,7 @@ class ScanForEmbeddedFiles extends Operation { Extension: ${type.fileDetails.extension} MIME type: ${type.fileDetails.mime}\n`; - if (type.fileDetails.description && type.fileDetails.description.length) { + if (type?.fileDetails?.description?.length) { output += ` Description: ${type.fileDetails.description}\n`; } }); diff --git a/src/core/operations/SharpenImage.mjs b/src/core/operations/SharpenImage.mjs index 3882b7aa..1f5461f2 100644 --- a/src/core/operations/SharpenImage.mjs +++ b/src/core/operations/SharpenImage.mjs @@ -8,16 +8,13 @@ import Operation from "../Operation.mjs"; import OperationError from "../errors/OperationError.mjs"; import { isImage } from "../lib/FileType.mjs"; import { toBase64 } from "../lib/Base64.mjs"; -import { gaussianBlur } from "../lib/ImageManipulation.mjs"; import { isWorkerEnvironment } from "../Utils.mjs"; -import jimplib from "jimp/es/index.js"; -const jimp = jimplib.default ? jimplib.default : jimplib; +import { Jimp, JimpMime } from "jimp"; /** * Sharpen Image operation */ class SharpenImage extends Operation { - /** * SharpenImage constructor */ @@ -36,22 +33,22 @@ class SharpenImage extends Operation { name: "Radius", type: "number", value: 2, - min: 1 + min: 1, }, { name: "Amount", type: "number", value: 1, min: 0, - step: 0.1 + step: 0.1, }, { name: "Threshold", type: "number", value: 10, min: 0, - max: 100 - } + max: 100, + }, ]; } @@ -69,7 +66,7 @@ class SharpenImage extends Operation { let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error loading image. (${err})`); } @@ -80,67 +77,102 @@ class SharpenImage extends Operation { const blurMask = image.clone(); if (isWorkerEnvironment()) - self.sendStatusMessage("Sharpening image... (Blurring cloned image)"); - const blurImage = gaussianBlur(image.clone(), radius); - + self.sendStatusMessage( + "Sharpening image... (Blurring cloned image)", + ); + const blurImage = image.clone().gaussian(radius); if (isWorkerEnvironment()) - self.sendStatusMessage("Sharpening image... (Creating unsharp mask)"); - blurMask.scan(0, 0, blurMask.bitmap.width, blurMask.bitmap.height, function(x, y, idx) { - const blurRed = blurImage.bitmap.data[idx]; - const blurGreen = blurImage.bitmap.data[idx + 1]; - const blurBlue = blurImage.bitmap.data[idx + 2]; + self.sendStatusMessage( + "Sharpening image... (Creating unsharp mask)", + ); + blurMask.scan( + 0, + 0, + blurMask.bitmap.width, + blurMask.bitmap.height, + function (x, y, idx) { + const blurRed = blurImage.bitmap.data[idx]; + const blurGreen = blurImage.bitmap.data[idx + 1]; + const blurBlue = blurImage.bitmap.data[idx + 2]; - const normalRed = this.bitmap.data[idx]; - const normalGreen = this.bitmap.data[idx + 1]; - const normalBlue = this.bitmap.data[idx + 2]; + const normalRed = this.bitmap.data[idx]; + const normalGreen = this.bitmap.data[idx + 1]; + const normalBlue = this.bitmap.data[idx + 2]; - // Subtract blurred pixel value from normal image - this.bitmap.data[idx] = (normalRed > blurRed) ? normalRed - blurRed : 0; - this.bitmap.data[idx + 1] = (normalGreen > blurGreen) ? normalGreen - blurGreen : 0; - this.bitmap.data[idx + 2] = (normalBlue > blurBlue) ? normalBlue - blurBlue : 0; - }); + // Subtract blurred pixel value from normal image + this.bitmap.data[idx] = + normalRed > blurRed ? normalRed - blurRed : 0; + this.bitmap.data[idx + 1] = + normalGreen > blurGreen ? normalGreen - blurGreen : 0; + this.bitmap.data[idx + 2] = + normalBlue > blurBlue ? normalBlue - blurBlue : 0; + }, + ); if (isWorkerEnvironment()) - self.sendStatusMessage("Sharpening image... (Merging with unsharp mask)"); - image.scan(0, 0, image.bitmap.width, image.bitmap.height, function(x, y, idx) { - let maskRed = blurMask.bitmap.data[idx]; - let maskGreen = blurMask.bitmap.data[idx + 1]; - let maskBlue = blurMask.bitmap.data[idx + 2]; + self.sendStatusMessage( + "Sharpening image... (Merging with unsharp mask)", + ); + image.scan( + 0, + 0, + image.bitmap.width, + image.bitmap.height, + function (x, y, idx) { + let maskRed = blurMask.bitmap.data[idx]; + let maskGreen = blurMask.bitmap.data[idx + 1]; + let maskBlue = blurMask.bitmap.data[idx + 2]; - const normalRed = this.bitmap.data[idx]; - const normalGreen = this.bitmap.data[idx + 1]; - const normalBlue = this.bitmap.data[idx + 2]; + const normalRed = this.bitmap.data[idx]; + const normalGreen = this.bitmap.data[idx + 1]; + const normalBlue = this.bitmap.data[idx + 2]; - // Calculate luminance - const maskLuminance = (0.2126 * maskRed + 0.7152 * maskGreen + 0.0722 * maskBlue); - const normalLuminance = (0.2126 * normalRed + 0.7152 * normalGreen + 0.0722 * normalBlue); + // Calculate luminance + const maskLuminance = + 0.2126 * maskRed + + 0.7152 * maskGreen + + 0.0722 * maskBlue; + const normalLuminance = + 0.2126 * normalRed + + 0.7152 * normalGreen + + 0.0722 * normalBlue; - let luminanceDiff; - if (maskLuminance > normalLuminance) { - luminanceDiff = maskLuminance - normalLuminance; - } else { - luminanceDiff = normalLuminance - maskLuminance; - } + let luminanceDiff; + if (maskLuminance > normalLuminance) { + luminanceDiff = maskLuminance - normalLuminance; + } else { + luminanceDiff = normalLuminance - maskLuminance; + } - // Scale mask colours by amount - maskRed = maskRed * amount; - maskGreen = maskGreen * amount; - maskBlue = maskBlue * amount; + // Scale mask colours by amount + maskRed = maskRed * amount; + maskGreen = maskGreen * amount; + maskBlue = maskBlue * amount; - // Only change pixel value if the difference is higher than threshold - if ((luminanceDiff / 255) * 100 >= threshold) { - this.bitmap.data[idx] = (normalRed + maskRed) <= 255 ? normalRed + maskRed : 255; - this.bitmap.data[idx + 1] = (normalGreen + maskGreen) <= 255 ? normalGreen + maskGreen : 255; - this.bitmap.data[idx + 2] = (normalBlue + maskBlue) <= 255 ? normalBlue + maskBlue : 255; - } - }); + // Only change pixel value if the difference is higher than threshold + if ((luminanceDiff / 255) * 100 >= threshold) { + this.bitmap.data[idx] = + normalRed + maskRed <= 255 ? + normalRed + maskRed : + 255; + this.bitmap.data[idx + 1] = + normalGreen + maskGreen <= 255 ? + normalGreen + maskGreen : + 255; + this.bitmap.data[idx + 2] = + normalBlue + maskBlue <= 255 ? + normalBlue + maskBlue : + 255; + } + }, + ); let imageBuffer; - if (image.getMIME() === "image/gif") { - imageBuffer = await image.getBufferAsync(jimp.MIME_PNG); + if (image.mime === "image/gif") { + imageBuffer = await image.getBuffer(JimpMime.png); } else { - imageBuffer = await image.getBufferAsync(jimp.AUTO); + imageBuffer = await image.getBuffer(image.mime); } return imageBuffer.buffer; } catch (err) { @@ -164,7 +196,6 @@ class SharpenImage extends Operation { return ``;
}
-
}
export default SharpenImage;
diff --git a/src/core/operations/ShowOnMap.mjs b/src/core/operations/ShowOnMap.mjs
index 9c81a27b..d75c2aa6 100644
--- a/src/core/operations/ShowOnMap.mjs
+++ b/src/core/operations/ShowOnMap.mjs
@@ -1,6 +1,7 @@
/**
* @author j433866 [j433866@gmail.com]
- * @copyright Crown Copyright 2019
+ * @author 0xff1ce [github.com/0xff1ce]
+ * @copyright Crown Copyright 2024
* @license Apache-2.0
*/
@@ -22,7 +23,7 @@ class ShowOnMap extends Operation {
this.name = "Show on map";
this.module = "Hashing";
this.description = "Displays co-ordinates on a slippy map.
Co-ordinates will be converted to decimal degrees before being shown on the map.
Supported formats:
This operation will not work offline."; - this.infoURL = "https://foundation.wikimedia.org/wiki/Maps_Terms_of_Use"; + this.infoURL = "https://osmfoundation.org/wiki/Terms_of_Use"; this.inputType = "string"; this.outputType = "string"; this.presentType = "html"; @@ -85,12 +86,19 @@ class ShowOnMap extends Operation { data = "0, 0"; } const zoomLevel = args[0]; - const tileUrl = "https://maps.wikimedia.org/osm-intl/{z}/{x}/{y}.png", - tileAttribution = "Wikimedia maps | © OpenStreetMap contributors", - leafletUrl = "https://unpkg.com/leaflet@1.5.0/dist/leaflet.js", - leafletCssUrl = "https://unpkg.com/leaflet@1.5.0/dist/leaflet.css"; + const tileUrl = "https://tile.openstreetmap.org/{z}/{x}/{y}.png", + tileAttribution = "© OpenStreetMap contributors", + leafletUrl = "https://unpkg.com/leaflet@1.9.4/dist/leaflet.js", + leafletCssUrl = "https://unpkg.com/leaflet@1.9.4/dist/leaflet.css"; return ` - + diff --git a/src/web/static/sitemap.mjs b/src/web/static/sitemap.mjs index b96047fc..4f8101d4 100644 --- a/src/web/static/sitemap.mjs +++ b/src/web/static/sitemap.mjs @@ -1,6 +1,5 @@ import sm from "sitemap"; -import OperationConfig from "../../core/config/OperationConfig.json" assert {type: "json"}; - +import OperationConfig from "../../core/config/OperationConfig.json" assert { type: "json" }; /** * Generates an XML sitemap for all CyberChef operations and a number of recipes. @@ -10,25 +9,25 @@ import OperationConfig from "../../core/config/OperationConfig.json" assert {typ * @license Apache-2.0 */ -const smStream = new sm.SitemapStream({ - hostname: "https://gchq.github.io/CyberChef", -}); +const baseUrl = "https://gchq.github.io/CyberChef/"; + +const smStream = new sm.SitemapStream({}); smStream.write({ - url: "/", + url: baseUrl, changefreq: "weekly", - priority: 1.0 + priority: 1.0, }); for (const op in OperationConfig) { smStream.write({ - url: `/?op=${encodeURIComponent(op)}`, + url: `${baseUrl}?op=${encodeURIComponent(op)}`, changeFreq: "yearly", - priority: 0.5 + priority: 0.5, }); } smStream.end(); sm.streamToPromise(smStream).then( - buffer => console.log(buffer.toString()) // eslint-disable-line no-console + (buffer) => console.log(buffer.toString()), // eslint-disable-line no-console ); diff --git a/src/web/static/structuredData.json b/src/web/static/structuredData.json index 08677281..e242f70e 100755 --- a/src/web/static/structuredData.json +++ b/src/web/static/structuredData.json @@ -1,23 +1,26 @@ [ { "@context": "http://schema.org", - "@type": "Organization", - "url": "https://gchq.github.io/CyberChef/", - "logo": "https://gchq.github.io/CyberChef/images/cyberchef-128x128.png", - "sameAs": [ - "https://github.com/gchq/CyberChef", - "https://www.npmjs.com/package/cyberchef" + "@graph": [ + { + "@type": "Organization", + "url": "https://gchq.github.io/CyberChef/", + "logo": "https://gchq.github.io/CyberChef/images/cyberchef-128x128.png", + "sameAs": [ + "https://github.com/gchq/CyberChef", + "https://www.npmjs.com/package/cyberchef" + ] + }, + { + "@type": "WebSite", + "url": "https://gchq.github.io/CyberChef/", + "name": "CyberChef", + "potentialAction": { + "@type": "SearchAction", + "target": "https://gchq.github.io/CyberChef/?op={operation_search_term}", + "query-input": "required name=operation_search_term" + } + } ] - }, - { - "@context": "http://schema.org", - "@type": "WebSite", - "url": "https://gchq.github.io/CyberChef/", - "name": "CyberChef", - "potentialAction": { - "@type": "SearchAction", - "target": "https://gchq.github.io/CyberChef/?op={operation_search_term}", - "query-input": "required name=operation_search_term" - } } -] +] \ No newline at end of file diff --git a/src/web/stylesheets/components/_list.css b/src/web/stylesheets/components/_list.css index 31e40837..b732b4c1 100755 --- a/src/web/stylesheets/components/_list.css +++ b/src/web/stylesheets/components/_list.css @@ -40,4 +40,13 @@ margin: 0 !important; border-radius: 0 !important; border: none; -} \ No newline at end of file +} + +.op-count { + float: right; + color: var(--subtext-font-colour); + font-weight: normal; + font-size: xx-small; + opacity: 0.5; + padding-left: .5em; +} diff --git a/src/web/stylesheets/components/_operation.css b/src/web/stylesheets/components/_operation.css index 7d45a9e2..a97fed70 100755 --- a/src/web/stylesheets/components/_operation.css +++ b/src/web/stylesheets/components/_operation.css @@ -27,17 +27,31 @@ } .ingredients { - display: grid; - grid-template-columns: auto auto auto; - grid-column-gap: 14px; + display: flex; + flex-flow: row wrap; + justify-content: flex-start; + column-gap: 14px; + row-gap: 0; } -.ingredients > div { - grid-column: 1 / span 3; +.ing-very-wide { + flex: 4 400px; } -.ingredients > div.inline { - grid-column: unset; +.ing-wide { + flex: 3 200px; +} + +.ing-medium { + flex: 2 120px; +} + +.ing-short { + flex: 1 80px; +} + +.ing-flexible { + flex-grow: 1; } .ingredients .form-group { @@ -55,6 +69,10 @@ select.arg { min-width: 100px; } +select.arg.form-control:not([size]):not([multiple]), select.custom-file-control:not([size]):not([multiple]) { + height: 100% !important; +} + textarea.arg { min-height: 74px; resize: vertical; @@ -64,6 +82,11 @@ div.toggle-string { flex: 1; } +input.toggle-string { + border-top-right-radius: 0 !important; + height: 100%; +} + .operation [class^='bmd-label'], .operation [class*=' bmd-label'] { top: 13px !important; @@ -160,7 +183,7 @@ div.toggle-string { } .input-group .form-control { - border-top-left-radius: 4px !important; + border-top-left-radius: 4px; } .input-group-append button { diff --git a/src/web/stylesheets/components/_pane.css b/src/web/stylesheets/components/_pane.css index f251fa27..54e67b3b 100755 --- a/src/web/stylesheets/components/_pane.css +++ b/src/web/stylesheets/components/_pane.css @@ -46,72 +46,6 @@ padding: 0; } -.io-card.card { - box-shadow: 0 4px 8px 0 rgba(0,0,0,0.2); - transition: 0.3s; - width: 400px; - height: 150px; - position: absolute; - top: 50%; - left: 50%; - transform: translate(-50%, -50%); - font-family: var(--primary-font-family); - color: var(--primary-font-colour); - line-height: 30px; - background-color: var(--primary-background-colour); - flex-direction: row; - padding-left: 10px; -} - -.io-card.card:hover { - box-shadow: 0 8px 16px 0 rgba(0,0,0,0.2); -} - -.io-card.card>img { - float: left; - width: auto; - height: auto; - max-width: 128px; - max-height: 128px; - margin-left: auto; - margin-top: auto; - margin-right: auto; - margin-bottom: auto; - padding: 0px; - -} - -.io-card.card .card-body .close { - position: absolute; - right: 10px; - top: 4px; -} - -.io-card.card .card-body { - float: left; - padding: 16px; - width: 250px; - white-space: nowrap; - overflow: hidden; - text-overflow: ellipsis; - user-select: text; -} - -.io-card.card .card-body>.btn { - margin-bottom: 5px; - margin-top: 5px; -} - -.io-card.card input[type=number] { - padding-right: 6px; - padding-left: 6px; - height: unset; -} - -.io-card.card .input-group { - padding-top: 5px; -} - #files .card-header .float-right a:hover { text-decoration: none; } diff --git a/src/web/stylesheets/index.css b/src/web/stylesheets/index.css index 960c7006..0565399f 100755 --- a/src/web/stylesheets/index.css +++ b/src/web/stylesheets/index.css @@ -36,4 +36,5 @@ @import "./layout/_structure.css"; /* Operations */ +@import "./operations/diff.css"; @import "./operations/json.css"; diff --git a/src/web/stylesheets/layout/_banner.css b/src/web/stylesheets/layout/_banner.css index 59856958..1ef5d766 100755 --- a/src/web/stylesheets/layout/_banner.css +++ b/src/web/stylesheets/layout/_banner.css @@ -26,6 +26,36 @@ color: var(--banner-url-colour); } +#options:focus { + background-color: #eef3ec; + border: solid black 2px; + border-radius: 4px; +} + +#support:focus { + background-color: #eef3ec; + border: solid black 2px; + border-radius: 4px; +} + +#notice:focus { + background-color: #eef3ec; + border: solid black 2px; + border-radius: 4px; +} + +#banner .col a:focus { + background-color: #eef3ec; + border: solid black 2px; + border-radius: 4px; +} + +#notice-wrapper #notice:focus { + background-color: #eef3ec; + border: solid black 2px; + border-radius: 4px; +} + #notice-wrapper { text-align: center; overflow: hidden; diff --git a/src/web/stylesheets/layout/_controls.css b/src/web/stylesheets/layout/_controls.css index c410704b..1edc41b5 100755 --- a/src/web/stylesheets/layout/_controls.css +++ b/src/web/stylesheets/layout/_controls.css @@ -6,27 +6,20 @@ * @license Apache-2.0 */ -:root { - --controls-height: 75px; -} - #controls { position: absolute; width: 100%; - height: var(--controls-height); bottom: 0; - padding: 0; - padding-top: 12px; + padding: 10px 0; border-top: 1px solid var(--primary-border-colour); background-color: var(--secondary-background-colour); } #controls-content { position: relative; - left: 50%; - top: 50%; - transform: translate(-50%, -50%); - transform-origin: center left; + display: flex; + flex-flow: row nowrap; + align-items: center; } #auto-bake-label { @@ -56,6 +49,7 @@ #controls .btn { border-radius: 30px; + margin: 0; } .output-maximised .hide-on-maximised-output { diff --git a/src/web/stylesheets/layout/_io.css b/src/web/stylesheets/layout/_io.css index 7811144a..0146bf27 100755 --- a/src/web/stylesheets/layout/_io.css +++ b/src/web/stylesheets/layout/_io.css @@ -7,41 +7,36 @@ */ #input-text, -#output-text, -#output-html { +#output-text { position: relative; width: 100%; height: 100%; margin: 0; - padding: 3px; - -moz-padding-start: 3px; - -moz-padding-end: 3px; - border: none; - border-width: 0px; - resize: none; background-color: transparent; - white-space: pre-wrap; - word-wrap: break-word; -} - -#output-wrapper{ - margin: 0; - padding: 0; -} - -#output-wrapper .textarea-wrapper { - width: 100%; - height: 100%; - box-sizing: border-box; overflow: hidden; - pointer-events: auto; + user-select: auto; } - +#output-text.html-output .cm-content, +#output-text.html-output .cm-line, #output-html { + display: block; + height: 100%; + user-select: auto; +} +#output-text.html-output .cm-line .cm-widgetBuffer, +#output-text.html-output .cm-line>br { display: none; - overflow-y: auto; - -moz-padding-start: 1px; /* Fixes bug in Firefox */ +} + +.cm-editor { + height: 100%; +} + +.cm-editor .cm-content { + font-family: var(--fixed-width-font-family); + font-size: var(--fixed-width-font-size); + color: var(--fixed-width-font-colour); } #input-tabs-wrapper #input-tabs, @@ -162,70 +157,25 @@ } #input-wrapper, -#output-wrapper, -#input-wrapper > * , -#output-wrapper > .textarea-wrapper > div, -#output-wrapper > .textarea-wrapper > textarea { +#output-wrapper { height: calc(100% - var(--title-height)); } #input-wrapper.show-tabs, -#input-wrapper.show-tabs > *, -#output-wrapper.show-tabs, -#output-wrapper.show-tabs > .textarea-wrapper > div, -#output-wrapper.show-tabs > .textarea-wrapper > textarea { +#output-wrapper.show-tabs { height: calc(100% - var(--tab-height) - var(--title-height)); } -#output-wrapper > .textarea-wrapper > #output-html { - height: 100%; -} - -#show-file-overlay { - height: 32px; -} - -.input-wrapper.textarea-wrapper { - width: 100%; - box-sizing: border-box; - overflow: hidden; - pointer-events: auto; -} - -.textarea-wrapper textarea, -.textarea-wrapper>div { - font-family: var(--fixed-width-font-family); - font-size: var(--fixed-width-font-size); - color: var(--fixed-width-font-colour); -} - -#input-highlighter, -#output-highlighter { - position: absolute; - left: 0; - bottom: 0; - width: 100%; - padding: 3px; - margin: 0; - overflow: hidden; - letter-spacing: normal; - white-space: pre-wrap; - word-wrap: break-word; - color: #fff; - background-color: transparent; - border: none; - pointer-events: none; -} - #output-loader { position: absolute; bottom: 0; left: 0; width: 100%; + height: 100%; margin: 0; - background-color: var(--primary-background-colour); - visibility: hidden; + background-color: var(--secondary-background-colour); opacity: 0; + visibility: hidden; display: flex; justify-content: center; align-items: center; @@ -254,31 +204,6 @@ transition: all 0.5s ease; } -#input-file, -#output-file { - position: absolute; - left: 0; - bottom: 0; - width: 100%; - display: none; -} - -.file-overlay { - position: absolute; - opacity: 0.8; - background-color: var(--title-background-colour); - width: 100%; - height: 100%; -} - -#show-file-overlay { - position: absolute; - right: 15px; - top: calc(var(--title-height) + 10px); - cursor: pointer; - display: none; -} - .io-info { margin-right: 18px; margin-top: 1px; @@ -292,10 +217,6 @@ align-items: center; } -#input-info { - line-height: 15px; -} - .dropping-file { border: 5px dashed var(--drop-file-border-colour) !important; } @@ -458,3 +379,214 @@ cursor: pointer; filter: brightness(98%); } + +/* Highlighting */ +.ͼ2.cm-focused .cm-selectionBackground { + background-color: var(--hl5); +} + +.ͼ2 .cm-selectionBackground { + background-color: var(--hl1); +} + +.ͼ1 .cm-selectionMatch { + background-color: var(--hl2); +} + +.ͼ1.cm-focused .cm-cursor.cm-cursor-primary { + border-color: var(--primary-font-colour); +} + +.ͼ1 .cm-cursor.cm-cursor-primary { + display: block; + border-color: var(--subtext-font-colour); +} + + +/* Status bar */ + +.cm-panel input::placeholder { + font-size: 12px !important; +} + +.ͼ2 .cm-panels, +.ͼ2 .cm-side-panels { + background-color: var(--secondary-background-colour); + border-color: var(--primary-border-colour); + color: var(--primary-font-colour); +} + +.cm-status-bar { + font-family: var(--fixed-width-font-family); + font-weight: normal; + font-size: 8pt; + margin: 0 5px; + display: flex; + flex-flow: row nowrap; + justify-content: space-between; + align-items: center; +} + +.cm-status-bar i { + font-size: 12pt; + vertical-align: middle; + margin-left: 8px; +} +.cm-status-bar>div>span:first-child i { + margin-left: 0; +} + +.cm-status-bar .disabled { + background-color: unset !important; + cursor: not-allowed; +} + +/* Dropup Button */ +.cm-status-bar-select-btn { + border: none; + cursor: pointer; +} + +/* The container
This algorithm uses an AES key (KEK: key-encryption key) and a 64-bit IV to decrypt 64-bit blocks."; + this.infoURL = "https://wikipedia.org/wiki/Key_wrap"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key (KEK)", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "a6a6a6a6a6a6a6a6", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Hex", "Raw"] + }, + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const kek = Utils.convertToByteString(args[0].string, args[0].option), + iv = Utils.convertToByteString(args[1].string, args[1].option), + inputType = args[2], + outputType = args[3]; + + if (kek.length !== 16 && kek.length !== 24 && kek.length !== 32) { + throw new OperationError("KEK must be either 16, 24, or 32 bytes (currently " + kek.length + " bytes)"); + } + if (iv.length !== 8) { + throw new OperationError("IV must be 8 bytes (currently " + iv.length + " bytes)"); + } + const inputData = Utils.convertToByteString(input, inputType); + if (inputData.length % 8 !== 0 || inputData.length < 24) { + throw new OperationError("input must be 8n (n>=3) bytes (currently " + inputData.length + " bytes)"); + } + + const cipher = forge.cipher.createCipher("AES-ECB", kek); + cipher.start(); + cipher.update(forge.util.createBuffer("")); + cipher.finish(); + const paddingBlock = cipher.output.getBytes(); + + const decipher = forge.cipher.createDecipher("AES-ECB", kek); + + let A = inputData.substring(0, 8); + const R = []; + for (let i = 8; i < inputData.length; i += 8) { + R.push(inputData.substring(i, i + 8)); + } + let cntLower = R.length >>> 0; + let cntUpper = (R.length / ((1 << 30) * 4)) >>> 0; + cntUpper = cntUpper * 6 + ((cntLower * 6 / ((1 << 30) * 4)) >>> 0); + cntLower = cntLower * 6 >>> 0; + for (let j = 5; j >= 0; j--) { + for (let i = R.length - 1; i >= 0; i--) { + const aBuffer = Utils.strToArrayBuffer(A); + const aView = new DataView(aBuffer); + aView.setUint32(0, aView.getUint32(0) ^ cntUpper); + aView.setUint32(4, aView.getUint32(4) ^ cntLower); + A = Utils.arrayBufferToStr(aBuffer, false); + decipher.start(); + decipher.update(forge.util.createBuffer(A + R[i] + paddingBlock)); + decipher.finish(); + const B = decipher.output.getBytes(); + A = B.substring(0, 8); + R[i] = B.substring(8, 16); + cntLower--; + if (cntLower < 0) { + cntUpper--; + cntLower = 0xffffffff; + } + } + } + if (A !== iv) { + throw new OperationError("IV mismatch"); + } + const P = R.join(""); + + if (outputType === "Hex") { + return toHexFast(Utils.strToArrayBuffer(P)); + } + return P; + } + +} + +export default AESKeyUnwrap; diff --git a/src/core/operations/AESKeyWrap.mjs b/src/core/operations/AESKeyWrap.mjs new file mode 100644 index 00000000..38867156 --- /dev/null +++ b/src/core/operations/AESKeyWrap.mjs @@ -0,0 +1,115 @@ +/** + * @author mikecat + * @copyright Crown Copyright 2022 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import Utils from "../Utils.mjs"; +import { toHexFast } from "../lib/Hex.mjs"; +import forge from "node-forge"; +import OperationError from "../errors/OperationError.mjs"; + +/** + * AES Key Wrap operation + */ +class AESKeyWrap extends Operation { + + /** + * AESKeyWrap constructor + */ + constructor() { + super(); + + this.name = "AES Key Wrap"; + this.module = "Ciphers"; + this.description = "A key wrapping algorithm defined in RFC3394, which is used to protect keys in untrusted storage or communications, using AES.
This algorithm uses an AES key (KEK: key-encryption key) and a 64-bit IV to encrypt 64-bit blocks."; + this.infoURL = "https://wikipedia.org/wiki/Key_wrap"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key (KEK)", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "a6a6a6a6a6a6a6a6", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Hex", "Raw"] + }, + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const kek = Utils.convertToByteString(args[0].string, args[0].option), + iv = Utils.convertToByteString(args[1].string, args[1].option), + inputType = args[2], + outputType = args[3]; + + if (kek.length !== 16 && kek.length !== 24 && kek.length !== 32) { + throw new OperationError("KEK must be either 16, 24, or 32 bytes (currently " + kek.length + " bytes)"); + } + if (iv.length !== 8) { + throw new OperationError("IV must be 8 bytes (currently " + iv.length + " bytes)"); + } + const inputData = Utils.convertToByteString(input, inputType); + if (inputData.length % 8 !== 0 || inputData.length < 16) { + throw new OperationError("input must be 8n (n>=2) bytes (currently " + inputData.length + " bytes)"); + } + + const cipher = forge.cipher.createCipher("AES-ECB", kek); + + let A = iv; + const R = []; + for (let i = 0; i < inputData.length; i += 8) { + R.push(inputData.substring(i, i + 8)); + } + let cntLower = 1, cntUpper = 0; + for (let j = 0; j < 6; j++) { + for (let i = 0; i < R.length; i++) { + cipher.start(); + cipher.update(forge.util.createBuffer(A + R[i])); + cipher.finish(); + const B = cipher.output.getBytes(); + const msbBuffer = Utils.strToArrayBuffer(B.substring(0, 8)); + const msbView = new DataView(msbBuffer); + msbView.setUint32(0, msbView.getUint32(0) ^ cntUpper); + msbView.setUint32(4, msbView.getUint32(4) ^ cntLower); + A = Utils.arrayBufferToStr(msbBuffer, false); + R[i] = B.substring(8, 16); + cntLower++; + if (cntLower > 0xffffffff) { + cntUpper++; + cntLower = 0; + } + } + } + const C = A + R.join(""); + + if (outputType === "Hex") { + return toHexFast(Utils.strToArrayBuffer(C)); + } + return C; + } + +} + +export default AESKeyWrap; diff --git a/src/core/operations/AMFDecode.mjs b/src/core/operations/AMFDecode.mjs new file mode 100644 index 00000000..50a0d551 --- /dev/null +++ b/src/core/operations/AMFDecode.mjs @@ -0,0 +1,52 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2022 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import "reflect-metadata"; // Required as a shim for the amf library +import { AMF0, AMF3 } from "@astronautlabs/amf"; + +/** + * AMF Decode operation + */ +class AMFDecode extends Operation { + + /** + * AMFDecode constructor + */ + constructor() { + super(); + + this.name = "AMF Decode"; + this.module = "Encodings"; + this.description = "Action Message Format (AMF) is a binary format used to serialize object graphs such as ActionScript objects and XML, or send messages between an Adobe Flash client and a remote service, usually a Flash Media Server or third party alternatives."; + this.infoURL = "https://wikipedia.org/wiki/Action_Message_Format"; + this.inputType = "ArrayBuffer"; + this.outputType = "JSON"; + this.args = [ + { + name: "Format", + type: "option", + value: ["AMF0", "AMF3"], + defaultIndex: 1 + } + ]; + } + + /** + * @param {ArrayBuffer} input + * @param {Object[]} args + * @returns {JSON} + */ + run(input, args) { + const [format] = args; + const handler = format === "AMF0" ? AMF0 : AMF3; + const encoded = new Uint8Array(input); + return handler.Value.deserialize(encoded); + } + +} + +export default AMFDecode; diff --git a/src/core/operations/AMFEncode.mjs b/src/core/operations/AMFEncode.mjs new file mode 100644 index 00000000..c21ba7dc --- /dev/null +++ b/src/core/operations/AMFEncode.mjs @@ -0,0 +1,52 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2022 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import "reflect-metadata"; // Required as a shim for the amf library +import { AMF0, AMF3 } from "@astronautlabs/amf"; + +/** + * AMF Encode operation + */ +class AMFEncode extends Operation { + + /** + * AMFEncode constructor + */ + constructor() { + super(); + + this.name = "AMF Encode"; + this.module = "Encodings"; + this.description = "Action Message Format (AMF) is a binary format used to serialize object graphs such as ActionScript objects and XML, or send messages between an Adobe Flash client and a remote service, usually a Flash Media Server or third party alternatives."; + this.infoURL = "https://wikipedia.org/wiki/Action_Message_Format"; + this.inputType = "JSON"; + this.outputType = "ArrayBuffer"; + this.args = [ + { + name: "Format", + type: "option", + value: ["AMF0", "AMF3"], + defaultIndex: 1 + } + ]; + } + + /** + * @param {JSON} input + * @param {Object[]} args + * @returns {ArrayBuffer} + */ + run(input, args) { + const [format] = args; + const handler = format === "AMF0" ? AMF0 : AMF3; + const output = handler.Value.any(input).serialize(); + return output.buffer; + } + +} + +export default AMFEncode; diff --git a/src/core/operations/AddLineNumbers.mjs b/src/core/operations/AddLineNumbers.mjs index c1c6159a..3eee6544 100644 --- a/src/core/operations/AddLineNumbers.mjs +++ b/src/core/operations/AddLineNumbers.mjs @@ -22,7 +22,13 @@ class AddLineNumbers extends Operation { this.description = "Adds line numbers to the output."; this.inputType = "string"; this.outputType = "string"; - this.args = []; + this.args = [ + { + "name": "Offset", + "type": "number", + "value": 0 + } + ]; } /** @@ -33,10 +39,11 @@ class AddLineNumbers extends Operation { run(input, args) { const lines = input.split("\n"), width = lines.length.toString().length; + const offset = args[0] ? parseInt(args[0], 10) : 0; let output = ""; for (let n = 0; n < lines.length; n++) { - output += (n+1).toString().padStart(width, " ") + " " + lines[n] + "\n"; + output += (n+1+offset).toString().padStart(width, " ") + " " + lines[n] + "\n"; } return output.slice(0, output.length-1); } diff --git a/src/core/operations/AddTextToImage.mjs b/src/core/operations/AddTextToImage.mjs index 231de14f..c137b492 100644 --- a/src/core/operations/AddTextToImage.mjs +++ b/src/core/operations/AddTextToImage.mjs @@ -9,14 +9,19 @@ import OperationError from "../errors/OperationError.mjs"; import { isImage } from "../lib/FileType.mjs"; import { toBase64 } from "../lib/Base64.mjs"; import { isWorkerEnvironment } from "../Utils.mjs"; -import jimplib from "jimp/es/index.js"; -const jimp = jimplib.default ? jimplib.default : jimplib; +import { + Jimp, + JimpMime, + ResizeStrategy, + measureText, + measureTextHeight, + loadFont, +} from "jimp"; /** * Add Text To Image operation */ class AddTextToImage extends Operation { - /** * AddTextToImage constructor */ @@ -25,7 +30,8 @@ class AddTextToImage extends Operation { this.name = "Add Text To Image"; this.module = "Image"; - this.description = "Adds text onto an image.
Text can be horizontally or vertically aligned, or the position can be manually specified.
Variants of the Roboto font face are available in any size or colour."; + this.description = + "Adds text onto an image.
Text can be horizontally or vertically aligned, or the position can be manually specified.
Variants of the Roboto font face are available in any size or colour."; this.infoURL = ""; this.inputType = "ArrayBuffer"; this.outputType = "ArrayBuffer"; @@ -34,72 +40,67 @@ class AddTextToImage extends Operation { { name: "Text", type: "string", - value: "" + value: "", }, { name: "Horizontal align", type: "option", - value: ["None", "Left", "Center", "Right"] + value: ["None", "Left", "Center", "Right"], }, { name: "Vertical align", type: "option", - value: ["None", "Top", "Middle", "Bottom"] + value: ["None", "Top", "Middle", "Bottom"], }, { name: "X position", type: "number", - value: 0 + value: 0, }, { name: "Y position", type: "number", - value: 0 + value: 0, }, { name: "Size", type: "number", value: 32, - min: 8 + min: 8, }, { name: "Font face", type: "option", - value: [ - "Roboto", - "Roboto Black", - "Roboto Mono", - "Roboto Slab" - ] + value: ["Roboto", "Roboto Black", "Roboto Mono", "Roboto Slab"], }, { name: "Red", type: "number", value: 255, min: 0, - max: 255 + max: 255, }, { name: "Green", type: "number", value: 255, min: 0, - max: 255 + max: 255, }, { name: "Blue", type: "number", value: 255, min: 0, - max: 255 + max: 255, }, { name: "Alpha", type: "number", value: 255, min: 0, - max: 255 - } + max: 255, + }, ]; } @@ -128,45 +129,64 @@ class AddTextToImage extends Operation { let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error loading image. (${err})`); } - try { - if (isWorkerEnvironment()) - self.sendStatusMessage("Adding text to image..."); - const fontsMap = {}; + if (isWorkerEnvironment()) + self.sendStatusMessage("Adding text to image..."); + + const fontsMap = {}; + try { const fonts = [ - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.fnt"), - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.fnt"), - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.fnt"), - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.fnt") + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.fnt" + ), + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.fnt" + ), + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.fnt" + ), + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.fnt" + ), ]; - await Promise.all(fonts) - .then(fonts => { - fontsMap.Roboto = fonts[0]; - fontsMap["Roboto Black"] = fonts[1]; - fontsMap["Roboto Mono"] = fonts[2]; - fontsMap["Roboto Slab"] = fonts[3]; - }); - - + await Promise.all(fonts).then((fonts) => { + fontsMap.Roboto = fonts[0]; + fontsMap["Roboto Black"] = fonts[1]; + fontsMap["Roboto Mono"] = fonts[2]; + fontsMap["Roboto Slab"] = fonts[3]; + }); // Make Webpack load the png font images await Promise.all([ - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.png"), - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.png"), - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.png"), - import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.png") + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.png" + ), + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.png" + ), + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.png" + ), + import( + /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.png" + ), ]); + } catch (err) { + throw new OperationError(`Error preparing fonts. (${err})`); + } + let jimpFont; + try { const font = fontsMap[fontFace]; // LoadFont needs an absolute url, so append the font name to self.docURL - const jimpFont = await jimp.loadFont(self.docURL + "/" + font.default); + jimpFont = await loadFont(self.docURL + "/" + font.default); - jimpFont.pages.forEach(function(page) { + jimpFont.pages.forEach(function (page) { if (page.bitmap) { // Adjust the RGB values of the image pages to change the font colour. const pageWidth = page.bitmap.width; @@ -176,32 +196,56 @@ class AddTextToImage extends Operation { const idx = (iy * pageWidth + ix) << 2; const newRed = page.bitmap.data[idx] - (255 - red); - const newGreen = page.bitmap.data[idx + 1] - (255 - green); - const newBlue = page.bitmap.data[idx + 2] - (255 - blue); - const newAlpha = page.bitmap.data[idx + 3] - (255 - alpha); + const newGreen = + page.bitmap.data[idx + 1] - (255 - green); + const newBlue = + page.bitmap.data[idx + 2] - (255 - blue); + const newAlpha = + page.bitmap.data[idx + 3] - (255 - alpha); // Make sure the bitmap values don't go below 0 as that makes jimp very unhappy - page.bitmap.data[idx] = (newRed > 0) ? newRed : 0; - page.bitmap.data[idx + 1] = (newGreen > 0) ? newGreen : 0; - page.bitmap.data[idx + 2] = (newBlue > 0) ? newBlue : 0; - page.bitmap.data[idx + 3] = (newAlpha > 0) ? newAlpha : 0; + page.bitmap.data[idx] = newRed > 0 ? newRed : 0; + page.bitmap.data[idx + 1] = + newGreen > 0 ? newGreen : 0; + page.bitmap.data[idx + 2] = + newBlue > 0 ? newBlue : 0; + page.bitmap.data[idx + 3] = + newAlpha > 0 ? newAlpha : 0; } } } }); + } catch (err) { + throw new OperationError(`Error loading font. (${err})`); + } + try { // Create a temporary image to hold the rendered text - const textImage = new jimp(jimp.measureText(jimpFont, text), jimp.measureTextHeight(jimpFont, text)); - textImage.print(jimpFont, 0, 0, text); + const textImage = new Jimp({ + width: measureText(jimpFont, text), + height: measureTextHeight(jimpFont, text), + }); + textImage.print({ + font: jimpFont, + x: 0, + y: 0, + text, + }); // Scale the rendered text image to the correct size const scaleFactor = size / 72; if (size !== 1) { // Use bicubic for decreasing size if (size > 1) { - textImage.scale(scaleFactor, jimp.RESIZE_BICUBIC); + textImage.scale({ + f: scaleFactor, + mode: ResizeStrategy.BICUBIC, + }); } else { - textImage.scale(scaleFactor, jimp.RESIZE_BILINEAR); + textImage.scale({ + f: scaleFactor, + mode: ResizeStrategy.BILINEAR, + }); } } @@ -211,10 +255,10 @@ class AddTextToImage extends Operation { xPos = 0; break; case "Center": - xPos = (image.getWidth() / 2) - (textImage.getWidth() / 2); + xPos = image.width / 2 - textImage.width / 2; break; case "Right": - xPos = image.getWidth() - textImage.getWidth(); + xPos = image.width - textImage.width; break; } @@ -223,25 +267,33 @@ class AddTextToImage extends Operation { yPos = 0; break; case "Middle": - yPos = (image.getHeight() / 2) - (textImage.getHeight() / 2); + yPos = image.height / 2 - textImage.height / 2; break; case "Bottom": - yPos = image.getHeight() - textImage.getHeight(); + yPos = image.height - textImage.height; break; } // Blit the rendered text image onto the original source image - image.blit(textImage, xPos, yPos); + image.blit({ + src: textImage, + x: xPos, + y: yPos, + }); + } catch (err) { + throw new OperationError(`Error adding text to image. (${err})`); + } + try { let imageBuffer; - if (image.getMIME() === "image/gif") { - imageBuffer = await image.getBufferAsync(jimp.MIME_PNG); + if (image.mime === "image/gif") { + imageBuffer = await image.getBuffer(JimpMime.png); } else { - imageBuffer = await image.getBufferAsync(jimp.AUTO); + imageBuffer = await image.getBuffer(image.mime); } return imageBuffer.buffer; } catch (err) { - throw new OperationError(`Error adding text to image. (${err})`); + throw new OperationError(`Error exporting image. (${err})`); } } @@ -262,7 +314,6 @@ class AddTextToImage extends Operation { return `
Enter the password in the input to generate its hash."; + this.infoURL = "https://wikipedia.org/wiki/Argon2"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Salt", + "type": "toggleString", + "value": "somesalt", + "toggleValues": ["UTF8", "Hex", "Base64", "Latin1"] + }, + { + "name": "Iterations", + "type": "number", + "value": 3 + }, + { + "name": "Memory (KiB)", + "type": "number", + "value": 4096 + }, + { + "name": "Parallelism", + "type": "number", + "value": 1 + }, + { + "name": "Hash length (bytes)", + "type": "number", + "value": 32 + }, + { + "name": "Type", + "type": "option", + "value": ["Argon2i", "Argon2d", "Argon2id"], + "defaultIndex": 0 + }, + { + "name": "Output format", + "type": "option", + "value": ["Encoded hash", "Hex hash", "Raw hash"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + async run(input, args) { + const argon2Types = { + "Argon2i": argon2.ArgonType.Argon2i, + "Argon2d": argon2.ArgonType.Argon2d, + "Argon2id": argon2.ArgonType.Argon2id + }; + + const salt = Utils.convertToByteString(args[0].string || "", args[0].option), + time = args[1], + mem = args[2], + parallelism = args[3], + hashLen = args[4], + type = argon2Types[args[5]], + outFormat = args[6]; + + try { + const result = await argon2.hash({ + pass: input, + salt, + time, + mem, + parallelism, + hashLen, + type, + }); + + switch (outFormat) { + case "Hex hash": + return result.hashHex; + case "Raw hash": + return Utils.arrayBufferToStr(result.hash); + case "Encoded hash": + default: + return result.encoded; + } + } catch (err) { + throw new OperationError(`Error: ${err.message}`); + } + } + +} + +export default Argon2; diff --git a/src/core/operations/Argon2Compare.mjs b/src/core/operations/Argon2Compare.mjs new file mode 100644 index 00000000..68e48ed0 --- /dev/null +++ b/src/core/operations/Argon2Compare.mjs @@ -0,0 +1,58 @@ +/** + * @author Tan Zhen Yong [tzy@beyondthesprawl.com] + * @copyright Crown Copyright 2019 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import argon2 from "argon2-browser"; + +/** + * Argon2 compare operation + */ +class Argon2Compare extends Operation { + + /** + * Argon2Compare constructor + */ + constructor() { + super(); + + this.name = "Argon2 compare"; + this.module = "Crypto"; + this.description = "Tests whether the input matches the given Argon2 hash. To test multiple possible passwords, use the 'Fork' operation."; + this.infoURL = "https://wikipedia.org/wiki/Argon2"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Encoded hash", + "type": "string", + "value": "" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + async run(input, args) { + const encoded = args[0]; + + try { + await argon2.verify({ + pass: input, + encoded + }); + + return `Match: ${input}`; + } catch (err) { + return "No match"; + } + } + +} + +export default Argon2Compare; diff --git a/src/core/operations/BLAKE3.mjs b/src/core/operations/BLAKE3.mjs new file mode 100644 index 00000000..0f686120 --- /dev/null +++ b/src/core/operations/BLAKE3.mjs @@ -0,0 +1,58 @@ +/** + * @author xumptex [xumptex@outlook.fr] + * @copyright Crown Copyright 2025 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import OperationError from "../errors/OperationError.mjs"; +import { blake3 } from "hash-wasm"; +/** + * BLAKE3 operation + */ +class BLAKE3 extends Operation { + + /** + * BLAKE3 constructor + */ + constructor() { + super(); + + this.name = "BLAKE3"; + this.module = "Hashing"; + this.description = "Hashes the input using BLAKE3 (UTF-8 encoded), with an optional key (also UTF-8), and outputs the result in hexadecimal format."; + this.infoURL = "https://en.wikipedia.org/wiki/BLAKE_(hash_function)#BLAKE3"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Size (bytes)", + "type": "number" + }, { + "name": "Key", + "type": "string", + "value": "" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = args[1]; + const size = args[0]; + // Check if the user want a key hash or not + if (key === "") { + return blake3(input, size*8); + } if (key.length !== 32) { + throw new OperationError("The key must be exactly 32 bytes long"); + } + return blake3(input, size*8, key); + } + +} + +export default BLAKE3; diff --git a/src/core/operations/BlowfishDecrypt.mjs b/src/core/operations/BlowfishDecrypt.mjs index f7dc8d17..afb26007 100644 --- a/src/core/operations/BlowfishDecrypt.mjs +++ b/src/core/operations/BlowfishDecrypt.mjs @@ -70,10 +70,14 @@ class BlowfishDecrypt extends Operation { inputType = args[3], outputType = args[4]; - if (key.length !== 8) { + if (key.length < 4 || key.length > 56) { throw new OperationError(`Invalid key length: ${key.length} bytes -Blowfish uses a key length of 8 bytes (64 bits).`); +Blowfish's key length needs to be between 4 and 56 bytes (32-448 bits).`); + } + + if (mode !== "ECB" && iv.length !== 8) { + throw new OperationError(`Invalid IV length: ${iv.length} bytes. Expected 8 bytes.`); } input = Utils.convertToByteString(input, inputType); diff --git a/src/core/operations/BlowfishEncrypt.mjs b/src/core/operations/BlowfishEncrypt.mjs index 2cf3672b..1d5dcf02 100644 --- a/src/core/operations/BlowfishEncrypt.mjs +++ b/src/core/operations/BlowfishEncrypt.mjs @@ -70,10 +70,14 @@ class BlowfishEncrypt extends Operation { inputType = args[3], outputType = args[4]; - if (key.length !== 8) { + if (key.length < 4 || key.length > 56) { throw new OperationError(`Invalid key length: ${key.length} bytes -Blowfish uses a key length of 8 bytes (64 bits).`); +Blowfish's key length needs to be between 4 and 56 bytes (32-448 bits).`); + } + + if (mode !== "ECB" && iv.length !== 8) { + throw new OperationError(`Invalid IV length: ${iv.length} bytes. Expected 8 bytes.`); } input = Utils.convertToByteString(input, inputType); diff --git a/src/core/operations/BlurImage.mjs b/src/core/operations/BlurImage.mjs index 5ae383a2..ba46080f 100644 --- a/src/core/operations/BlurImage.mjs +++ b/src/core/operations/BlurImage.mjs @@ -9,15 +9,12 @@ import OperationError from "../errors/OperationError.mjs"; import { isWorkerEnvironment } from "../Utils.mjs"; import { isImage } from "../lib/FileType.mjs"; import { toBase64 } from "../lib/Base64.mjs"; -import { gaussianBlur } from "../lib/ImageManipulation.mjs"; -import jimplib from "jimp/es/index.js"; -const jimp = jimplib.default ? jimplib.default : jimplib; +import { Jimp, JimpMime } from "jimp"; /** * Blur Image operation */ class BlurImage extends Operation { - /** * BlurImage constructor */ @@ -26,7 +23,8 @@ class BlurImage extends Operation { this.name = "Blur Image"; this.module = "Image"; - this.description = "Applies a blur effect to the image.
Gaussian blur is much slower than fast blur, but produces better results."; + this.description = + "Applies a blur effect to the image.
Gaussian blur is much slower than fast blur, but produces better results."; this.infoURL = "https://wikipedia.org/wiki/Gaussian_blur"; this.inputType = "ArrayBuffer"; this.outputType = "ArrayBuffer"; @@ -36,13 +34,13 @@ class BlurImage extends Operation { name: "Amount", type: "number", value: 5, - min: 1 + min: 1, }, { name: "Type", type: "option", - value: ["Fast", "Gaussian"] - } + value: ["Fast", "Gaussian"], + }, ]; } @@ -60,7 +58,7 @@ class BlurImage extends Operation { let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error loading image. (${err})`); } @@ -74,15 +72,15 @@ class BlurImage extends Operation { case "Gaussian": if (isWorkerEnvironment()) self.sendStatusMessage("Gaussian blurring image..."); - image = gaussianBlur(image, blurAmount); + image.gaussian(blurAmount); break; } let imageBuffer; - if (image.getMIME() === "image/gif") { - imageBuffer = await image.getBufferAsync(jimp.MIME_PNG); + if (image.mime === "image/gif") { + imageBuffer = await image.getBuffer(JimpMime.png); } else { - imageBuffer = await image.getBufferAsync(jimp.AUTO); + imageBuffer = await image.getBuffer(image.mime); } return imageBuffer.buffer; } catch (err) { @@ -107,7 +105,6 @@ class BlurImage extends Operation { return `
RFC4493 defines AES-CMAC that uses AES encryption with a 128-bit key.
NIST SP 800-38B suggests usages of AES with other key lengths and Triple DES."; + this.infoURL = "https://wikipedia.org/wiki/CMAC"; + this.inputType = "ArrayBuffer"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Encryption algorithm", + "type": "option", + "value": ["AES", "Triple DES"] + } + ]; + } + + /** + * @param {ArrayBuffer} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteString(args[0].string, args[0].option); + const algo = args[1]; + + const info = (function() { + switch (algo) { + case "AES": + if (key.length !== 16 && key.length !== 24 && key.length !== 32) { + throw new OperationError("The key for AES must be either 16, 24, or 32 bytes (currently " + key.length + " bytes)"); + } + return { + "algorithm": "AES-ECB", + "key": key, + "blockSize": 16, + "Rb": new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x87]), + }; + case "Triple DES": + if (key.length !== 16 && key.length !== 24) { + throw new OperationError("The key for Triple DES must be 16 or 24 bytes (currently " + key.length + " bytes)"); + } + return { + "algorithm": "3DES-ECB", + "key": key.length === 16 ? key + key.substring(0, 8) : key, + "blockSize": 8, + "Rb": new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0x1b]), + }; + default: + throw new OperationError("Undefined encryption algorithm"); + } + })(); + + const xor = function(a, b, out) { + if (!out) out = new Uint8Array(a.length); + for (let i = 0; i < a.length; i++) { + out[i] = a[i] ^ b[i]; + } + return out; + }; + + const leftShift1 = function(a) { + const out = new Uint8Array(a.length); + let carry = 0; + for (let i = a.length - 1; i >= 0; i--) { + out[i] = (a[i] << 1) | carry; + carry = a[i] >> 7; + } + return out; + }; + + const cipher = forge.cipher.createCipher(info.algorithm, info.key); + const encrypt = function(a, out) { + if (!out) out = new Uint8Array(a.length); + cipher.start(); + cipher.update(forge.util.createBuffer(a)); + cipher.finish(); + const cipherText = cipher.output.getBytes(); + for (let i = 0; i < a.length; i++) { + out[i] = cipherText.charCodeAt(i); + } + return out; + }; + + const L = encrypt(new Uint8Array(info.blockSize)); + const K1 = leftShift1(L); + if (L[0] & 0x80) xor(K1, info.Rb, K1); + const K2 = leftShift1(K1); + if (K1[0] & 0x80) xor(K2, info.Rb, K2); + + const n = Math.ceil(input.byteLength / info.blockSize); + const lastBlock = (function() { + if (n === 0) { + const data = new Uint8Array(K2); + data[0] ^= 0x80; + return data; + } + const inputLast = new Uint8Array(input, info.blockSize * (n - 1)); + if (inputLast.length === info.blockSize) { + return xor(inputLast, K1, inputLast); + } else { + const data = new Uint8Array(info.blockSize); + data.set(inputLast, 0); + data[inputLast.length] = 0x80; + return xor(data, K2, data); + } + })(); + + const X = new Uint8Array(info.blockSize); + const Y = new Uint8Array(info.blockSize); + for (let i = 0; i < n - 1; i++) { + xor(X, new Uint8Array(input, info.blockSize * i, info.blockSize), Y); + encrypt(Y, X); + } + xor(lastBlock, X, Y); + const T = encrypt(Y); + return toHexFast(T); + } + +} + +export default CMAC; diff --git a/src/core/operations/CRC16Checksum.mjs b/src/core/operations/CRC16Checksum.mjs deleted file mode 100644 index 035ee04b..00000000 --- a/src/core/operations/CRC16Checksum.mjs +++ /dev/null @@ -1,41 +0,0 @@ -/** - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - */ - -import Operation from "../Operation.mjs"; -import JSCRC from "js-crc"; - -/** - * CRC-16 Checksum operation - */ -class CRC16Checksum extends Operation { - - /** - * CRC16Checksum constructor - */ - constructor() { - super(); - - this.name = "CRC-16 Checksum"; - this.module = "Crypto"; - this.description = "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.
The CRC was invented by W. Wesley Peterson in 1961."; - this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check"; - this.inputType = "ArrayBuffer"; - this.outputType = "string"; - this.args = []; - } - - /** - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - run(input, args) { - return JSCRC.crc16(input); - } - -} - -export default CRC16Checksum; diff --git a/src/core/operations/CRC32Checksum.mjs b/src/core/operations/CRC32Checksum.mjs deleted file mode 100644 index cfe84643..00000000 --- a/src/core/operations/CRC32Checksum.mjs +++ /dev/null @@ -1,41 +0,0 @@ -/** - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - */ - -import Operation from "../Operation.mjs"; -import JSCRC from "js-crc"; - -/** - * CRC-32 Checksum operation - */ -class CRC32Checksum extends Operation { - - /** - * CRC32Checksum constructor - */ - constructor() { - super(); - - this.name = "CRC-32 Checksum"; - this.module = "Crypto"; - this.description = "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.
The CRC was invented by W. Wesley Peterson in 1961; the 32-bit CRC function of Ethernet and many other standards is the work of several researchers and was published in 1975."; - this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check"; - this.inputType = "ArrayBuffer"; - this.outputType = "string"; - this.args = []; - } - - /** - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - run(input, args) { - return JSCRC.crc32(input); - } - -} - -export default CRC32Checksum; diff --git a/src/core/operations/CRC8Checksum.mjs b/src/core/operations/CRC8Checksum.mjs deleted file mode 100644 index 193cadf9..00000000 --- a/src/core/operations/CRC8Checksum.mjs +++ /dev/null @@ -1,157 +0,0 @@ -/** - * @author mshwed [m@ttshwed.com] - * @copyright Crown Copyright 2019 - * @license Apache-2.0 - */ - -import Operation from "../Operation.mjs"; -import OperationError from "../errors/OperationError.mjs"; - -import { toHexFast } from "../lib/Hex.mjs"; - -/** - * CRC-8 Checksum operation - */ -class CRC8Checksum extends Operation { - - /** - * CRC8Checksum constructor - */ - constructor() { - super(); - - this.name = "CRC-8 Checksum"; - this.module = "Crypto"; - this.description = "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.
The CRC was invented by W. Wesley Peterson in 1961."; - this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check"; - this.inputType = "ArrayBuffer"; - this.outputType = "string"; - this.args = [ - { - "name": "Algorithm", - "type": "option", - "value": [ - "CRC-8", - "CRC-8/CDMA2000", - "CRC-8/DARC", - "CRC-8/DVB-S2", - "CRC-8/EBU", - "CRC-8/I-CODE", - "CRC-8/ITU", - "CRC-8/MAXIM", - "CRC-8/ROHC", - "CRC-8/WCDMA" - ] - } - ]; - } - - /** - * Generates the pre-computed lookup table for byte division - * - * @param polynomial - */ - calculateCRC8LookupTable(polynomial) { - const crc8Table = new Uint8Array(256); - - let currentByte; - for (let i = 0; i < 256; i++) { - currentByte = i; - for (let bit = 0; bit < 8; bit++) { - if ((currentByte & 0x80) !== 0) { - currentByte <<= 1; - currentByte ^= polynomial; - } else { - currentByte <<= 1; - } - } - - crc8Table[i] = currentByte; - } - - return crc8Table; - } - - /** - * Calculates the CRC-8 Checksum from an input - * - * @param {ArrayBuffer} input - * @param {number} polynomial - * @param {number} initializationValue - * @param {boolean} inputReflection - * @param {boolean} outputReflection - * @param {number} xorOut - */ - calculateCRC8(input, polynomial, initializationValue, inputReflection, outputReflection, xorOut) { - const crcSize = 8; - const crcTable = this.calculateCRC8LookupTable(polynomial); - - let crc = initializationValue !== 0 ? initializationValue : 0; - let currentByte, position; - - input = new Uint8Array(input); - for (const inputByte of input) { - currentByte = inputReflection ? this.reverseBits(inputByte, crcSize) : inputByte; - - position = (currentByte ^ crc) & 255; - crc = crcTable[position]; - } - - crc = outputReflection ? this.reverseBits(crc, crcSize) : crc; - - if (xorOut !== 0) crc = crc ^ xorOut; - - return toHexFast(new Uint8Array([crc])); - } - - /** - * Reverse the bits for a given input byte. - * - * @param {number} input - */ - reverseBits(input, hashSize) { - let reversedByte = 0; - for (let i = hashSize - 1; i >= 0; i--) { - reversedByte |= ((input & 1) << i); - input >>= 1; - } - - return reversedByte; - } - - /** - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - run(input, args) { - const algorithm = args[0]; - - switch (algorithm) { - case "CRC-8": - return this.calculateCRC8(input, 0x7, 0x0, false, false, 0x0); - case "CRC-8/CDMA2000": - return this.calculateCRC8(input, 0x9B, 0xFF, false, false, 0x0); - case "CRC-8/DARC": - return this.calculateCRC8(input, 0x39, 0x0, true, true, 0x0); - case "CRC-8/DVB-S2": - return this.calculateCRC8(input, 0xD5, 0x0, false, false, 0x0); - case "CRC-8/EBU": - return this.calculateCRC8(input, 0x1D, 0xFF, true, true, 0x0); - case "CRC-8/I-CODE": - return this.calculateCRC8(input, 0x1D, 0xFD, false, false, 0x0); - case "CRC-8/ITU": - return this.calculateCRC8(input, 0x7, 0x0, false, false, 0x55); - case "CRC-8/MAXIM": - return this.calculateCRC8(input, 0x31, 0x0, true, true, 0x0); - case "CRC-8/ROHC": - return this.calculateCRC8(input, 0x7, 0xFF, true, true, 0x0); - case "CRC-8/WCDMA": - return this.calculateCRC8(input, 0x9B, 0x0, true, true, 0x0); - default: - throw new OperationError("Unknown checksum algorithm"); - } - } -} - -export default CRC8Checksum; diff --git a/src/core/operations/CRCChecksum.mjs b/src/core/operations/CRCChecksum.mjs new file mode 100644 index 00000000..88da2fa5 --- /dev/null +++ b/src/core/operations/CRCChecksum.mjs @@ -0,0 +1,1110 @@ +/** + * @author r4mos [2k95ljkhg@mozmail.com] + * @copyright Crown Copyright 2025 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import OperationError from "../errors/OperationError.mjs"; + +/** + * CRC Checksum operation + */ +class CRCChecksum extends Operation { + + /** + * CRCChecksum constructor + */ + constructor() { + super(); + + this.name = "CRC Checksum"; + this.module = "Default"; + this.description = "A Cyclic Redundancy Check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data."; + this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check"; + this.inputType = "ArrayBuffer"; + this.outputType = "string"; + this.args = [ + { + name: "Algorithm", + type: "argSelector", + value: [ + { + name: "Custom", + on: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-3/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-3/ROHC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-4/G-704", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-4/INTERLAKEN", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-4/ITU", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-5/EPC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-5/EPC-C1G2", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-5/G-704", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-5/ITU", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-5/USB", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-6/CDMA2000-A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-6/CDMA2000-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-6/DARC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-6/G-704", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-6/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-6/ITU", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-7/MMC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-7/ROHC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-7/UMTS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/8H2F", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/AES", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/AUTOSAR", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/BLUETOOTH", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/CDMA2000", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/DARC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/DVB-S2", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/EBU", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/GSM-A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/GSM-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/HITAG", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/I-432-1", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/I-CODE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/ITU", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/LTE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/MAXIM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/MAXIM-DOW", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/MIFARE-MAD", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/NRSC-5", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/OPENSAFETY", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/ROHC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/SAE-J1850", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/SAE-J1850-ZERO", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/SMBUS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/TECH-3250", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-8/WCDMA", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-10/ATM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-10/CDMA2000", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-10/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-10/I-610", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-11/FLEXRAY", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-11/UMTS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-12/3GPP", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-12/CDMA2000", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-12/DECT", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-12/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-12/UMTS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-13/BBC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-14/DARC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-14/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-15/CAN", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-15/MPT1327", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/ACORN", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/ARC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/AUG-CCITT", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/AUTOSAR", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/BLUETOOTH", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/BUYPASS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/CCITT", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/CCITT-FALSE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/CCITT-TRUE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/CCITT-ZERO", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/CDMA2000", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/CMS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/DARC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/DDS-110", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/DECT-R", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/DECT-X", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/DNP", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/EN-13757", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/EPC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/EPC-C1G2", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/GENIBUS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/I-CODE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/IBM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/IBM-3740", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/IBM-SDLC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/IEC-61158-2", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/ISO-HDLC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/ISO-IEC-14443-3-A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/ISO-IEC-14443-3-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/KERMIT", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/LHA", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/LJ1200", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/LTE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/M17", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/MAXIM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/MAXIM-DOW", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/MCRF4XX", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/MODBUS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/NRSC-5", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/OPENSAFETY-A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/OPENSAFETY-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/PROFIBUS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/RIELLO", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/SPI-FUJITSU", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/T10-DIF", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/TELEDISK", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/TMS37157", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/UMTS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/USB", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/V-41-LSB", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/V-41-MSB", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/VERIFONE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/X-25", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/XMODEM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-16/ZMODEM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-17/CAN-FD", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-21/CAN-FD", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/BLE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/FLEXRAY-A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/FLEXRAY-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/INTERLAKEN", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/LTE-A", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/LTE-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/OPENPGP", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-24/OS-9", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-30/CDMA", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-31/PHILIPS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/AAL5", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/ADCCP", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/AIXM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/AUTOSAR", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/BASE91-C", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/BASE91-D", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/BZIP2", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/C", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/CASTAGNOLI", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/CD-ROM-EDC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/CKSUM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/D", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/DECT-B", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/INTERLAKEN", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/ISCSI", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/ISO-HDLC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/JAMCRC", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/MEF", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/MPEG-2", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/NVME", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/PKZIP", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/POSIX", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/Q", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/SATA", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/V-42", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/XFER", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-32/XZ", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-40/GSM", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/ECMA-182", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/GO-ECMA", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/GO-ISO", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/MS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/NVME", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/REDIS", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/WE", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-64/XZ", + off: [1, 2, 3, 4, 5, 6] + }, + { + name: "CRC-82/DARC", + off: [1, 2, 3, 4, 5, 6] + } + ] + }, + { + name: "Width (bits)", + type: "toggleString", + value: "0", + toggleValues: ["Decimal"] + }, + { + name: "Polynomial", + type: "toggleString", + value: "0", + toggleValues: ["Hex"] + }, + { + name: "Initialization", + type: "toggleString", + value: "0", + toggleValues: ["Hex"] + }, + { + name: "Reflect input", + type: "option", + value: ["True", "False"] + }, + { + name: "Reflect output", + type: "option", + value: ["True", "False"] + }, + { + name: "Xor Output", + type: "toggleString", + value: "0", + toggleValues: ["Hex"] + } + ]; + } + + /** + * Reverse the order of bits in a number + * + * @param {BigInt} data + * @param {BigInt} reflect + */ + reflectData(data, reflect) { + let value = 0n; + for (let bit = 0n; bit < reflect; bit++) { + if ((data & 1n) === 1n) { + value |= (1n << ((reflect - 1n) - bit)); + } + data >>= 1n; + } + return value; + } + + /** + * Performs the CRC Checksum calculation bit per bit without acceleration + * + * @param {BigInt} width + * @param {ArrayBuffer} input + * @param {BigInt} poly + * @param {BigInt} remainder + * @param {boolean} reflectIn + * @param {boolean} reflectOut + * @param {BigInt} xorOut + */ + calculateCrcBitPerBit(width, input, poly, remainder, reflectIn, reflectOut, xorOut) { + const TOP_BIT = 1n << (width - 1n); + const MASK = (1n << width) - 1n; + + for (let byte of input) { + byte = BigInt(byte); + if (reflectIn) { + byte = this.reflectData(byte, 8n); + } + + for (let i = 0x80n; i !== 0n; i >>= 1n) { + let bit = remainder & TOP_BIT; + + remainder = (remainder << 1n) & MASK; + + if ((byte & i) !== 0n) { + bit ^= TOP_BIT; + } + + if (bit !== 0n) { + remainder ^= poly; + } + } + } + + if (reflectOut) { + remainder = this.reflectData(remainder, width); + } + + return remainder ^ xorOut; + } + + /** + * Generates the necessary table to speed up the calculation + * + * @param {BigInt} width + * @param {BigInt} poly + * @param {BigInt} MASK + * @param {BigInt} TOP_BIT + */ + generateTable(width, poly, MASK, TOP_BIT) { + const table = new Array(256n); + for (let byte = 0n; byte < 256n; byte++) { + let value = ((byte << width - 8n) & MASK); + for (let bit = 0n; bit < 8n; bit++) { + value = (value & TOP_BIT) === 0n ? + ((value << 1n) & MASK) : + ((value << 1n) & MASK) ^ poly; + } + table[byte] = value; + } + return table; + } + + /** + * Performs the CRC Checksum calculation byte per byte using a computed table to accelerate it + * + * @param {BigInt} width + * @param {ArrayBuffer} input + * @param {BigInt} poly + * @param {BigInt} remainder + * @param {boolean} reflectIn + * @param {boolean} reflectOut + * @param {BigInt} xorOut + */ + calculateCrcBytePerByte(width, input, poly, remainder, reflectIn, reflectOut, xorOut) { + const TOP_BIT = 1n << (width - 1n); + const MASK = (1n << width) - 1n; + const TABLE = this.generateTable(width, poly, MASK, TOP_BIT); + + for (let byte of input) { + byte = BigInt(byte); + if (reflectIn) { + byte = this.reflectData(byte, 8n); + } + remainder ^= (byte << width - 8n) & MASK; + + const INDEX = remainder >> width - 8n; + remainder = (remainder << 8n) & MASK; + remainder ^= TABLE[INDEX]; + } + + if (reflectOut) { + remainder = this.reflectData(remainder, width); + } + return remainder ^ xorOut; + } + + /** + * Calculates the CRC Checksum using Bigint (https://developer.mozilla.org/en-US/docs/Glossary/BigInt) + * + * @param {BigInt} width + * @param {ArrayBuffer} input + * @param {BigInt} poly + * @param {BigInt} init + * @param {boolean} reflectIn + * @param {boolean} reflectOut + * @param {BigInt} xorOut + */ + crc(width, input, poly, init, reflectIn, reflectOut, xorOut) { + const VALUE = width < 8n ? + this.calculateCrcBitPerBit(width, input, poly, init, reflectIn, reflectOut, xorOut) : + this.calculateCrcBytePerByte(width, input, poly, init, reflectIn, reflectOut, xorOut); + + return VALUE.toString(16).padStart(Math.ceil(Number(width) / 4), "0"); + } + + /** + * Validates user input to perform a custom CRC + * + * @param {Object} widthObject + * @param {ArrayBuffer} input + * @param {Object} polyObject + * @param {Object} initObject + * @param {Object} reflectInObject + * @param {Object} reflectOutObject + * @param {Object} xorOutObject + */ + custom(widthObject, input, polyObject, initObject, reflectInObject, reflectOutObject, xorOutObject) { + try { + const width = BigInt(widthObject.string); + const poly = BigInt("0x" + polyObject.string); + const init = BigInt("0x" + initObject.string); + const reflectIn = reflectInObject === "True"; + const reflectOut = reflectOutObject === "True"; + const xorOut = BigInt("0x" + xorOutObject.string); + + return this.crc(width, input, poly, init, reflectIn, reflectOut, xorOut); + } catch (error) { + throw new OperationError("Invalid custom CRC arguments"); + } + } + + /** + * Calculation of all known CRCs. Names and constants extracted from https://reveng.sourceforge.io/crc-catalogue/all.htm + * + * @param {ArrayBuffer} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const algorithm = args[0]; + input = new Uint8Array(input); + + switch (algorithm) { + case "Custom": return this.custom(args[1], input, args[2], args[3], args[4], args[5], args[6]); + case "CRC-3/GSM": return this.crc(3n, input, 0x3n, 0x0n, false, false, 0x7n); + case "CRC-3/ROHC": return this.crc(3n, input, 0x3n, 0x7n, true, true, 0x0n); + case "CRC-4/G-704": return this.crc(4n, input, 0x3n, 0x0n, true, true, 0x0n); + case "CRC-4/INTERLAKEN": return this.crc(4n, input, 0x3n, 0xFn, false, false, 0xFn); + case "CRC-4/ITU": return this.crc(4n, input, 0x3n, 0x0n, true, true, 0x0n); + case "CRC-5/EPC": return this.crc(5n, input, 0x09n, 0x09n, false, false, 0x00n); + case "CRC-5/EPC-C1G2": return this.crc(5n, input, 0x09n, 0x09n, false, false, 0x00n); + case "CRC-5/G-704": return this.crc(5n, input, 0x15n, 0x00n, true, true, 0x00n); + case "CRC-5/ITU": return this.crc(5n, input, 0x15n, 0x00n, true, true, 0x00n); + case "CRC-5/USB": return this.crc(5n, input, 0x05n, 0x1Fn, true, true, 0x1Fn); + case "CRC-6/CDMA2000-A": return this.crc(6n, input, 0x27n, 0x3Fn, false, false, 0x00n); + case "CRC-6/CDMA2000-B": return this.crc(6n, input, 0x07n, 0x3Fn, false, false, 0x00n); + case "CRC-6/DARC": return this.crc(6n, input, 0x19n, 0x00n, true, true, 0x00n); + case "CRC-6/G-704": return this.crc(6n, input, 0x03n, 0x00n, true, true, 0x00n); + case "CRC-6/GSM": return this.crc(6n, input, 0x2Fn, 0x00n, false, false, 0x3Fn); + case "CRC-6/ITU": return this.crc(6n, input, 0x03n, 0x00n, true, true, 0x00n); + case "CRC-7/MMC": return this.crc(7n, input, 0x09n, 0x00n, false, false, 0x00n); + case "CRC-7/ROHC": return this.crc(7n, input, 0x4Fn, 0x7Fn, true, true, 0x00n); + case "CRC-7/UMTS": return this.crc(7n, input, 0x45n, 0x00n, false, false, 0x00n); + case "CRC-8": return this.crc(8n, input, 0x07n, 0x00n, false, false, 0x00n); + case "CRC-8/8H2F": return this.crc(8n, input, 0x2Fn, 0xFFn, false, false, 0xFFn); + case "CRC-8/AES": return this.crc(8n, input, 0x1Dn, 0xFFn, true, true, 0x00n); + case "CRC-8/AUTOSAR": return this.crc(8n, input, 0x2Fn, 0xFFn, false, false, 0xFFn); + case "CRC-8/BLUETOOTH": return this.crc(8n, input, 0xA7n, 0x00n, true, true, 0x00n); + case "CRC-8/CDMA2000": return this.crc(8n, input, 0x9Bn, 0xFFn, false, false, 0x00n); + case "CRC-8/DARC": return this.crc(8n, input, 0x39n, 0x00n, true, true, 0x00n); + case "CRC-8/DVB-S2": return this.crc(8n, input, 0xD5n, 0x00n, false, false, 0x00n); + case "CRC-8/EBU": return this.crc(8n, input, 0x1Dn, 0xFFn, true, true, 0x00n); + case "CRC-8/GSM-A": return this.crc(8n, input, 0x1Dn, 0x00n, false, false, 0x00n); + case "CRC-8/GSM-B": return this.crc(8n, input, 0x49n, 0x00n, false, false, 0xFFn); + case "CRC-8/HITAG": return this.crc(8n, input, 0x1Dn, 0xFFn, false, false, 0x00n); + case "CRC-8/I-432-1": return this.crc(8n, input, 0x07n, 0x00n, false, false, 0x55n); + case "CRC-8/I-CODE": return this.crc(8n, input, 0x1Dn, 0xFDn, false, false, 0x00n); + case "CRC-8/ITU": return this.crc(8n, input, 0x07n, 0x00n, false, false, 0x55n); + case "CRC-8/LTE": return this.crc(8n, input, 0x9Bn, 0x00n, false, false, 0x00n); + case "CRC-8/MAXIM": return this.crc(8n, input, 0x31n, 0x00n, true, true, 0x00n); + case "CRC-8/MAXIM-DOW": return this.crc(8n, input, 0x31n, 0x00n, true, true, 0x00n); + case "CRC-8/MIFARE-MAD": return this.crc(8n, input, 0x1Dn, 0xC7n, false, false, 0x00n); + case "CRC-8/NRSC-5": return this.crc(8n, input, 0x31n, 0xFFn, false, false, 0x00n); + case "CRC-8/OPENSAFETY": return this.crc(8n, input, 0x2Fn, 0x00n, false, false, 0x00n); + case "CRC-8/ROHC": return this.crc(8n, input, 0x07n, 0xFFn, true, true, 0x00n); + case "CRC-8/SAE-J1850": return this.crc(8n, input, 0x1Dn, 0xFFn, false, false, 0xFFn); + case "CRC-8/SAE-J1850-ZERO": return this.crc(8n, input, 0x1Dn, 0x00n, false, false, 0x00n); + case "CRC-8/SMBUS": return this.crc(8n, input, 0x07n, 0x00n, false, false, 0x00n); + case "CRC-8/TECH-3250": return this.crc(8n, input, 0x1Dn, 0xFFn, true, true, 0x00n); + case "CRC-8/WCDMA": return this.crc(8n, input, 0x9Bn, 0x00n, true, true, 0x00n); + case "CRC-10/ATM": return this.crc(10n, input, 0x233n, 0x000n, false, false, 0x000n); + case "CRC-10/CDMA2000": return this.crc(10n, input, 0x3D9n, 0x3FFn, false, false, 0x000n); + case "CRC-10/GSM": return this.crc(10n, input, 0x175n, 0x000n, false, false, 0x3FFn); + case "CRC-10/I-610": return this.crc(10n, input, 0x233n, 0x000n, false, false, 0x000n); + case "CRC-11/FLEXRAY": return this.crc(11n, input, 0x385n, 0x01An, false, false, 0x000n); + case "CRC-11/UMTS": return this.crc(11n, input, 0x307n, 0x000n, false, false, 0x000n); + case "CRC-12/3GPP": return this.crc(12n, input, 0x80Fn, 0x000n, false, true, 0x000n); + case "CRC-12/CDMA2000": return this.crc(12n, input, 0xF13n, 0xFFFn, false, false, 0x000n); + case "CRC-12/DECT": return this.crc(12n, input, 0x80Fn, 0x000n, false, false, 0x000n); + case "CRC-12/GSM": return this.crc(12n, input, 0xD31n, 0x000n, false, false, 0xFFFn); + case "CRC-12/UMTS": return this.crc(12n, input, 0x80Fn, 0x000n, false, true, 0x000n); + case "CRC-13/BBC": return this.crc(13n, input, 0x1CF5n, 0x0000n, false, false, 0x0000n); + case "CRC-14/DARC": return this.crc(14n, input, 0x0805n, 0x0000n, true, true, 0x0000n); + case "CRC-14/GSM": return this.crc(14n, input, 0x202Dn, 0x0000n, false, false, 0x3FFFn); + case "CRC-15/CAN": return this.crc(15n, input, 0x4599n, 0x0000n, false, false, 0x0000n); + case "CRC-15/MPT1327": return this.crc(15n, input, 0x6815n, 0x0000n, false, false, 0x0001n); + case "CRC-16": return this.crc(16n, input, 0x8005n, 0x0000n, true, true, 0x0000n); + case "CRC-16/A": return this.crc(16n, input, 0x1021n, 0xC6C6n, true, true, 0x0000n); + case "CRC-16/ACORN": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0x0000n); + case "CRC-16/ARC": return this.crc(16n, input, 0x8005n, 0x0000n, true, true, 0x0000n); + case "CRC-16/AUG-CCITT": return this.crc(16n, input, 0x1021n, 0x1D0Fn, false, false, 0x0000n); + case "CRC-16/AUTOSAR": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0x0000n); + case "CRC-16/B": return this.crc(16n, input, 0x1021n, 0xFFFFn, true, true, 0xFFFFn); + case "CRC-16/BLUETOOTH": return this.crc(16n, input, 0x1021n, 0x0000n, true, true, 0x0000n); + case "CRC-16/BUYPASS": return this.crc(16n, input, 0x8005n, 0x0000n, false, false, 0x0000n); + case "CRC-16/CCITT": return this.crc(16n, input, 0x1021n, 0x0000n, true, true, 0x0000n); + case "CRC-16/CCITT-FALSE": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0x0000n); + case "CRC-16/CCITT-TRUE": return this.crc(16n, input, 0x1021n, 0x0000n, true, true, 0x0000n); + case "CRC-16/CCITT-ZERO": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0x0000n); + case "CRC-16/CDMA2000": return this.crc(16n, input, 0xC867n, 0xFFFFn, false, false, 0x0000n); + case "CRC-16/CMS": return this.crc(16n, input, 0x8005n, 0xFFFFn, false, false, 0x0000n); + case "CRC-16/DARC": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/DDS-110": return this.crc(16n, input, 0x8005n, 0x800Dn, false, false, 0x0000n); + case "CRC-16/DECT-R": return this.crc(16n, input, 0x0589n, 0x0000n, false, false, 0x0001n); + case "CRC-16/DECT-X": return this.crc(16n, input, 0x0589n, 0x0000n, false, false, 0x0000n); + case "CRC-16/DNP": return this.crc(16n, input, 0x3D65n, 0x0000n, true, true, 0xFFFFn); + case "CRC-16/EN-13757": return this.crc(16n, input, 0x3D65n, 0x0000n, false, false, 0xFFFFn); + case "CRC-16/EPC": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/EPC-C1G2": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/GENIBUS": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/GSM": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0xFFFFn); + case "CRC-16/I-CODE": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/IBM": return this.crc(16n, input, 0x8005n, 0x0000n, true, true, 0x0000n); + case "CRC-16/IBM-3740": return this.crc(16n, input, 0x1021n, 0xFFFFn, false, false, 0x0000n); + case "CRC-16/IBM-SDLC": return this.crc(16n, input, 0x1021n, 0xFFFFn, true, true, 0xFFFFn); + case "CRC-16/IEC-61158-2": return this.crc(16n, input, 0x1DCFn, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/ISO-HDLC": return this.crc(16n, input, 0x1021n, 0xFFFFn, true, true, 0xFFFFn); + case "CRC-16/ISO-IEC-14443-3-A": return this.crc(16n, input, 0x1021n, 0xC6C6n, true, true, 0x0000n); + case "CRC-16/ISO-IEC-14443-3-B": return this.crc(16n, input, 0x1021n, 0xFFFFn, true, true, 0xFFFFn); + case "CRC-16/KERMIT": return this.crc(16n, input, 0x1021n, 0x0000n, true, true, 0x0000n); + case "CRC-16/LHA": return this.crc(16n, input, 0x8005n, 0x0000n, true, true, 0x0000n); + case "CRC-16/LJ1200": return this.crc(16n, input, 0x6F63n, 0x0000n, false, false, 0x0000n); + case "CRC-16/LTE": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0x0000n); + case "CRC-16/M17": return this.crc(16n, input, 0x5935n, 0xFFFFn, false, false, 0x0000n); + case "CRC-16/MAXIM": return this.crc(16n, input, 0x8005n, 0x0000n, true, true, 0xFFFFn); + case "CRC-16/MAXIM-DOW": return this.crc(16n, input, 0x8005n, 0x0000n, true, true, 0xFFFFn); + case "CRC-16/MCRF4XX": return this.crc(16n, input, 0x1021n, 0xFFFFn, true, true, 0x0000n); + case "CRC-16/MODBUS": return this.crc(16n, input, 0x8005n, 0xFFFFn, true, true, 0x0000n); + case "CRC-16/NRSC-5": return this.crc(16n, input, 0x080Bn, 0xFFFFn, true, true, 0x0000n); + case "CRC-16/OPENSAFETY-A": return this.crc(16n, input, 0x5935n, 0x0000n, false, false, 0x0000n); + case "CRC-16/OPENSAFETY-B": return this.crc(16n, input, 0x755Bn, 0x0000n, false, false, 0x0000n); + case "CRC-16/PROFIBUS": return this.crc(16n, input, 0x1DCFn, 0xFFFFn, false, false, 0xFFFFn); + case "CRC-16/RIELLO": return this.crc(16n, input, 0x1021n, 0xB2AAn, true, true, 0x0000n); + case "CRC-16/SPI-FUJITSU": return this.crc(16n, input, 0x1021n, 0x1D0Fn, false, false, 0x0000n); + case "CRC-16/T10-DIF": return this.crc(16n, input, 0x8BB7n, 0x0000n, false, false, 0x0000n); + case "CRC-16/TELEDISK": return this.crc(16n, input, 0xA097n, 0x0000n, false, false, 0x0000n); + case "CRC-16/TMS37157": return this.crc(16n, input, 0x1021n, 0x89ECn, true, true, 0x0000n); + case "CRC-16/UMTS": return this.crc(16n, input, 0x8005n, 0x0000n, false, false, 0x0000n); + case "CRC-16/USB": return this.crc(16n, input, 0x8005n, 0xFFFFn, true, true, 0xFFFFn); + case "CRC-16/V-41-LSB": return this.crc(16n, input, 0x1021n, 0x0000n, true, true, 0x0000n); + case "CRC-16/V-41-MSB": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0x0000n); + case "CRC-16/VERIFONE": return this.crc(16n, input, 0x8005n, 0x0000n, false, false, 0x0000n); + case "CRC-16/X-25": return this.crc(16n, input, 0x1021n, 0xFFFFn, true, true, 0xFFFFn); + case "CRC-16/XMODEM": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0x0000n); + case "CRC-16/ZMODEM": return this.crc(16n, input, 0x1021n, 0x0000n, false, false, 0x0000n); + case "CRC-17/CAN-FD": return this.crc(17n, input, 0x1685Bn, 0x00000n, false, false, 0x00000n); + case "CRC-21/CAN-FD": return this.crc(21n, input, 0x102899n, 0x000000n, false, false, 0x000000n); + case "CRC-24/BLE": return this.crc(24n, input, 0x00065Bn, 0x555555n, true, true, 0x000000n); + case "CRC-24/FLEXRAY-A": return this.crc(24n, input, 0x5D6DCBn, 0xFEDCBAn, false, false, 0x000000n); + case "CRC-24/FLEXRAY-B": return this.crc(24n, input, 0x5D6DCBn, 0xABCDEFn, false, false, 0x000000n); + case "CRC-24/INTERLAKEN": return this.crc(24n, input, 0x328B63n, 0xFFFFFFn, false, false, 0xFFFFFFn); + case "CRC-24/LTE-A": return this.crc(24n, input, 0x864CFBn, 0x000000n, false, false, 0x000000n); + case "CRC-24/LTE-B": return this.crc(24n, input, 0x800063n, 0x000000n, false, false, 0x000000n); + case "CRC-24/OPENPGP": return this.crc(24n, input, 0x864CFBn, 0xB704CEn, false, false, 0x000000n); + case "CRC-24/OS-9": return this.crc(24n, input, 0x800063n, 0xFFFFFFn, false, false, 0xFFFFFFn); + case "CRC-30/CDMA": return this.crc(30n, input, 0x2030B9C7n, 0x3FFFFFFFn, false, false, 0x3FFFFFFFn); + case "CRC-31/PHILIPS": return this.crc(31n, input, 0x04C11DB7n, 0x7FFFFFFFn, false, false, 0x7FFFFFFFn); + case "CRC-32": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/AAL5": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, false, false, 0xFFFFFFFFn); + case "CRC-32/ADCCP": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/AIXM": return this.crc(32n, input, 0x814141ABn, 0x00000000n, false, false, 0x00000000n); + case "CRC-32/AUTOSAR": return this.crc(32n, input, 0xF4ACFB13n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/BASE91-C": return this.crc(32n, input, 0x1EDC6F41n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/BASE91-D": return this.crc(32n, input, 0xA833982Bn, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/BZIP2": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, false, false, 0xFFFFFFFFn); + case "CRC-32/C": return this.crc(32n, input, 0x1EDC6F41n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/CASTAGNOLI": return this.crc(32n, input, 0x1EDC6F41n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/CD-ROM-EDC": return this.crc(32n, input, 0x8001801Bn, 0x00000000n, true, true, 0x00000000n); + case "CRC-32/CKSUM": return this.crc(32n, input, 0x04C11DB7n, 0x00000000n, false, false, 0xFFFFFFFFn); + case "CRC-32/D": return this.crc(32n, input, 0xA833982Bn, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/DECT-B": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, false, false, 0xFFFFFFFFn); + case "CRC-32/INTERLAKEN": return this.crc(32n, input, 0x1EDC6F41n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/ISCSI": return this.crc(32n, input, 0x1EDC6F41n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/ISO-HDLC": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/JAMCRC": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0x00000000n); + case "CRC-32/MEF": return this.crc(32n, input, 0x741B8CD7n, 0xFFFFFFFFn, true, true, 0x00000000n); + case "CRC-32/MPEG-2": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, false, false, 0x00000000n); + case "CRC-32/NVME": return this.crc(32n, input, 0x1EDC6F41n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/PKZIP": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/POSIX": return this.crc(32n, input, 0x04C11DB7n, 0x00000000n, false, false, 0xFFFFFFFFn); + case "CRC-32/Q": return this.crc(32n, input, 0x814141ABn, 0x00000000n, false, false, 0x00000000n); + case "CRC-32/SATA": return this.crc(32n, input, 0x04C11DB7n, 0x52325032n, false, false, 0x00000000n); + case "CRC-32/V-42": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-32/XFER": return this.crc(32n, input, 0x000000AFn, 0x00000000n, false, false, 0x00000000n); + case "CRC-32/XZ": return this.crc(32n, input, 0x04C11DB7n, 0xFFFFFFFFn, true, true, 0xFFFFFFFFn); + case "CRC-40/GSM": return this.crc(40n, input, 0x0004820009n, 0x0000000000n, false, false, 0xFFFFFFFFFFn); + case "CRC-64/ECMA-182": return this.crc(64n, input, 0x42F0E1EBA9EA3693n, 0x0000000000000000n, false, false, 0x0000000000000000n); + case "CRC-64/GO-ECMA": return this.crc(64n, input, 0x42F0E1EBA9EA3693n, 0xFFFFFFFFFFFFFFFFn, true, true, 0xFFFFFFFFFFFFFFFFn); + case "CRC-64/GO-ISO": return this.crc(64n, input, 0x000000000000001Bn, 0xFFFFFFFFFFFFFFFFn, true, true, 0xFFFFFFFFFFFFFFFFn); + case "CRC-64/MS": return this.crc(64n, input, 0x259C84CBA6426349n, 0xFFFFFFFFFFFFFFFFn, true, true, 0x0000000000000000n); + case "CRC-64/NVME": return this.crc(64n, input, 0xAD93D23594C93659n, 0xFFFFFFFFFFFFFFFFn, true, true, 0xFFFFFFFFFFFFFFFFn); + case "CRC-64/REDIS": return this.crc(64n, input, 0xAD93D23594C935A9n, 0x0000000000000000n, true, true, 0x0000000000000000n); + case "CRC-64/WE": return this.crc(64n, input, 0x42F0E1EBA9EA3693n, 0xFFFFFFFFFFFFFFFFn, false, false, 0xFFFFFFFFFFFFFFFFn); + case "CRC-64/XZ": return this.crc(64n, input, 0x42F0E1EBA9EA3693n, 0xFFFFFFFFFFFFFFFFn, true, true, 0xFFFFFFFFFFFFFFFFn); + case "CRC-82/DARC": return this.crc(82n, input, 0x0308C0111011401440411n, 0x000000000000000000000n, true, true, 0x000000000000000000000n); + default: throw new OperationError("Unknown checksum algorithm"); + } + } + +} + +export default CRCChecksum; diff --git a/src/core/operations/CSSSelector.mjs b/src/core/operations/CSSSelector.mjs index d6b8da11..639726c4 100644 --- a/src/core/operations/CSSSelector.mjs +++ b/src/core/operations/CSSSelector.mjs @@ -6,7 +6,7 @@ import Operation from "../Operation.mjs"; import OperationError from "../errors/OperationError.mjs"; -import xmldom from "xmldom"; +import xmldom from "@xmldom/xmldom"; import nwmatcher from "nwmatcher"; /** diff --git a/src/core/operations/CTPH.mjs b/src/core/operations/CTPH.mjs index 7394faaa..6b6a487d 100644 --- a/src/core/operations/CTPH.mjs +++ b/src/core/operations/CTPH.mjs @@ -21,7 +21,7 @@ class CTPH extends Operation { this.name = "CTPH"; this.module = "Crypto"; this.description = "Context Triggered Piecewise Hashing, also called Fuzzy Hashing, can match inputs that have homologies. Such inputs have sequences of identical bytes in the same order, although bytes in between these sequences may be different in both content and length.
CTPH was originally based on the work of Dr. Andrew Tridgell and a spam email detector called SpamSum. This method was adapted by Jesse Kornblum and published at the DFRWS conference in 2006 in a paper 'Identifying Almost Identical Files Using Context Triggered Piecewise Hashing'."; - this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Context_Triggered_Piecewise_Hashing"; + this.infoURL = "https://forensics.wiki/context_triggered_piecewise_hashing/"; this.inputType = "string"; this.outputType = "string"; this.args = []; diff --git a/src/core/operations/CaretMdecode.mjs b/src/core/operations/CaretMdecode.mjs new file mode 100644 index 00000000..68c6dacb --- /dev/null +++ b/src/core/operations/CaretMdecode.mjs @@ -0,0 +1,98 @@ +/** + * @author tedk [tedk@ted.do] + * @copyright Crown Copyright 2024 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; + +/** + * Caret/M-decode operation + * + * https://gist.githubusercontent.com/JaHIY/3c91bbf7bea5661e6abfbd1349ee81a2/raw/c7b480e9ff24bcb8f5287a8a8a2dcb9bf5628506/decode_m_notation.cpp + */ +class CaretMdecode extends Operation { + + /** + * CaretMdecode constructor + */ + constructor() { + super(); + + this.name = "Caret/M-decode"; + this.module = "Default"; + this.description = "Decodes caret or M-encoded strings, i.e. ^M turns into a newline, M-^] turns into 0x9d. Sources such as `cat -v`.\n\nPlease be aware that when using `cat -v` ^_ (caret-underscore) will not be encoded, but represents a valid encoding (namely that of 0x1f)."; + this.infoURL = "https://en.wikipedia.org/wiki/Caret_notation"; + this.inputType = "string"; + this.outputType = "byteArray"; + this.args = []; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {byteArray} + */ + run(input, args) { + + const bytes = []; + + let prev = ""; + + for (let i = 0; i < input.length; i++) { + + const charCode = input.charCodeAt(i); + const curChar = input.charAt(i); + + if (prev === "M-^") { + if (charCode > 63 && charCode <= 95) { + bytes.push(charCode + 64); + } else if (charCode === 63) { + bytes.push(255); + } else { + bytes.push(77, 45, 94, charCode); + } + prev = ""; + } else if (prev === "M-") { + if (curChar === "^") { + prev = prev + "^"; + } else if (charCode >= 32 && charCode <= 126) { + bytes.push(charCode + 128); + prev = ""; + } else { + bytes.push(77, 45, charCode); + prev = ""; + } + } else if (prev === "M") { + if (curChar === "-") { + prev = prev + "-"; + } else { + bytes.push(77, charCode); + prev = ""; + } + } else if (prev === "^") { + if (charCode > 63 && charCode <= 126) { + bytes.push(charCode - 64); + } else if (charCode === 63) { + bytes.push(127); + } else { + bytes.push(94, charCode); + } + prev = ""; + } else { + if (curChar === "M") { + prev = "M"; + } else if (curChar === "^") { + prev = "^"; + } else { + bytes.push(charCode); + } + } + + } + return bytes; + } + +} + +export default CaretMdecode; diff --git a/src/core/operations/ChaCha.mjs b/src/core/operations/ChaCha.mjs new file mode 100644 index 00000000..2d186d35 --- /dev/null +++ b/src/core/operations/ChaCha.mjs @@ -0,0 +1,234 @@ +/** + * @author joostrijneveld [joost@joostrijneveld.nl] + * @copyright Crown Copyright 2022 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import OperationError from "../errors/OperationError.mjs"; +import Utils from "../Utils.mjs"; +import { toHex } from "../lib/Hex.mjs"; + +/** + * Computes the ChaCha block function + * + * @param {byteArray} key + * @param {byteArray} nonce + * @param {byteArray} counter + * @param {integer} rounds + * @returns {byteArray} + */ +function chacha(key, nonce, counter, rounds) { + const tau = "expand 16-byte k"; + const sigma = "expand 32-byte k"; + + let state, c; + if (key.length === 16) { + c = Utils.strToByteArray(tau); + state = c.concat(key).concat(key); + } else { + c = Utils.strToByteArray(sigma); + state = c.concat(key); + } + state = state.concat(counter).concat(nonce); + + const x = Array(); + for (let i = 0; i < 64; i += 4) { + x.push(Utils.byteArrayToInt(state.slice(i, i + 4), "little")); + } + const a = [...x]; + + /** + * Macro to compute a 32-bit rotate-left operation + * + * @param {integer} x + * @param {integer} n + * @returns {integer} + */ + function ROL32(x, n) { + return ((x << n) & 0xFFFFFFFF) | (x >>> (32 - n)); + } + + /** + * Macro to compute a single ChaCha quarterround operation + * + * @param {integer} x + * @param {integer} a + * @param {integer} b + * @param {integer} c + * @param {integer} d + * @returns {integer} + */ + function quarterround(x, a, b, c, d) { + x[a] = ((x[a] + x[b]) & 0xFFFFFFFF); x[d] = ROL32(x[d] ^ x[a], 16); + x[c] = ((x[c] + x[d]) & 0xFFFFFFFF); x[b] = ROL32(x[b] ^ x[c], 12); + x[a] = ((x[a] + x[b]) & 0xFFFFFFFF); x[d] = ROL32(x[d] ^ x[a], 8); + x[c] = ((x[c] + x[d]) & 0xFFFFFFFF); x[b] = ROL32(x[b] ^ x[c], 7); + } + + for (let i = 0; i < rounds / 2; i++) { + quarterround(x, 0, 4, 8, 12); + quarterround(x, 1, 5, 9, 13); + quarterround(x, 2, 6, 10, 14); + quarterround(x, 3, 7, 11, 15); + quarterround(x, 0, 5, 10, 15); + quarterround(x, 1, 6, 11, 12); + quarterround(x, 2, 7, 8, 13); + quarterround(x, 3, 4, 9, 14); + } + + for (let i = 0; i < 16; i++) { + x[i] = (x[i] + a[i]) & 0xFFFFFFFF; + } + + let output = Array(); + for (let i = 0; i < 16; i++) { + output = output.concat(Utils.intToByteArray(x[i], 4, "little")); + } + return output; +} + +/** + * ChaCha operation + */ +class ChaCha extends Operation { + + /** + * ChaCha constructor + */ + constructor() { + super(); + + this.name = "ChaCha"; + this.module = "Ciphers"; + this.description = "ChaCha is a stream cipher designed by Daniel J. Bernstein. It is a variant of the Salsa stream cipher. Several parameterizations exist; 'ChaCha' may refer to the original construction, or to the variant as described in RFC-8439. ChaCha is often used with Poly1305, in the ChaCha20-Poly1305 AEAD construction.
Key: ChaCha uses a key of 16 or 32 bytes (128 or 256 bits).
Nonce: ChaCha uses a nonce of 8 or 12 bytes (64 or 96 bits).
Counter: ChaCha uses a counter of 4 or 8 bytes (32 or 64 bits); together, the nonce and counter must add up to 16 bytes. The counter starts at zero at the start of the keystream, and is incremented at every 64 bytes."; + this.infoURL = "https://wikipedia.org/wiki/Salsa20#ChaCha_variant"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Nonce", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64", "Integer"] + }, + { + "name": "Counter", + "type": "number", + "value": 0, + "min": 0 + }, + { + "name": "Rounds", + "type": "option", + "value": ["20", "12", "8"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Raw", "Hex"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string, args[0].option), + nonceType = args[1].option, + rounds = parseInt(args[3], 10), + inputType = args[4], + outputType = args[5]; + + if (key.length !== 16 && key.length !== 32) { + throw new OperationError(`Invalid key length: ${key.length} bytes. + +ChaCha uses a key of 16 or 32 bytes (128 or 256 bits).`); + } + + let counter, nonce, counterLength; + if (nonceType === "Integer") { + nonce = Utils.intToByteArray(parseInt(args[1].string, 10), 12, "little"); + counterLength = 4; + } else { + nonce = Utils.convertToByteArray(args[1].string, args[1].option); + if (!(nonce.length === 12 || nonce.length === 8)) { + throw new OperationError(`Invalid nonce length: ${nonce.length} bytes. + +ChaCha uses a nonce of 8 or 12 bytes (64 or 96 bits).`); + } + counterLength = 16 - nonce.length; + } + counter = Utils.intToByteArray(args[2], counterLength, "little"); + + const output = []; + input = Utils.convertToByteArray(input, inputType); + + let counterAsInt = Utils.byteArrayToInt(counter, "little"); + for (let i = 0; i < input.length; i += 64) { + counter = Utils.intToByteArray(counterAsInt, counterLength, "little"); + const stream = chacha(key, nonce, counter, rounds); + for (let j = 0; j < 64 && i + j < input.length; j++) { + output.push(input[i + j] ^ stream[j]); + } + counterAsInt++; + } + + if (outputType === "Hex") { + return toHex(output); + } else { + return Utils.arrayBufferToStr(Uint8Array.from(output).buffer); + } + } + + /** + * Highlight ChaCha + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlight(pos, args) { + const inputType = args[4], + outputType = args[5]; + if (inputType === "Raw" && outputType === "Raw") { + return pos; + } + } + + /** + * Highlight ChaCha in reverse + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlightReverse(pos, args) { + const inputType = args[4], + outputType = args[5]; + if (inputType === "Raw" && outputType === "Raw") { + return pos; + } + } + +} + +export default ChaCha; diff --git a/src/core/operations/CompareCTPHHashes.mjs b/src/core/operations/CompareCTPHHashes.mjs index 40fec472..91956220 100644 --- a/src/core/operations/CompareCTPHHashes.mjs +++ b/src/core/operations/CompareCTPHHashes.mjs @@ -24,7 +24,7 @@ class CompareCTPHHashes extends Operation { this.name = "Compare CTPH hashes"; this.module = "Crypto"; this.description = "Compares two Context Triggered Piecewise Hashing (CTPH) fuzzy hashes to determine the similarity between them on a scale of 0 to 100."; - this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Context_Triggered_Piecewise_Hashing"; + this.infoURL = "https://forensics.wiki/context_triggered_piecewise_hashing/"; this.inputType = "string"; this.outputType = "Number"; this.args = [ diff --git a/src/core/operations/CompareSSDEEPHashes.mjs b/src/core/operations/CompareSSDEEPHashes.mjs index 806b048e..9937d7e6 100644 --- a/src/core/operations/CompareSSDEEPHashes.mjs +++ b/src/core/operations/CompareSSDEEPHashes.mjs @@ -24,7 +24,7 @@ class CompareSSDEEPHashes extends Operation { this.name = "Compare SSDEEP hashes"; this.module = "Crypto"; this.description = "Compares two SSDEEP fuzzy hashes to determine the similarity between them on a scale of 0 to 100."; - this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Ssdeep"; + this.infoURL = "https://forensics.wiki/ssdeep/"; this.inputType = "string"; this.outputType = "Number"; this.args = [ diff --git a/src/core/operations/ContainImage.mjs b/src/core/operations/ContainImage.mjs index a93d3569..0304733b 100644 --- a/src/core/operations/ContainImage.mjs +++ b/src/core/operations/ContainImage.mjs @@ -9,14 +9,18 @@ import OperationError from "../errors/OperationError.mjs"; import { isImage } from "../lib/FileType.mjs"; import { toBase64 } from "../lib/Base64.mjs"; import { isWorkerEnvironment } from "../Utils.mjs"; -import jimplib from "jimp/es/index.js"; -const jimp = jimplib.default ? jimplib.default : jimplib; +import { + Jimp, + JimpMime, + ResizeStrategy, + HorizontalAlign, + VerticalAlign, +} from "jimp"; /** * Contain Image operation */ class ContainImage extends Operation { - /** * ContainImage constructor */ @@ -25,7 +29,8 @@ class ContainImage extends Operation { this.name = "Contain Image"; this.module = "Image"; - this.description = "Scales an image to the specified width and height, maintaining the aspect ratio. The image may be letterboxed."; + this.description = + "Scales an image to the specified width and height, maintaining the aspect ratio. The image may be letterboxed."; this.infoURL = ""; this.inputType = "ArrayBuffer"; this.outputType = "ArrayBuffer"; @@ -35,33 +40,25 @@ class ContainImage extends Operation { name: "Width", type: "number", value: 100, - min: 1 + min: 1, }, { name: "Height", type: "number", value: 100, - min: 1 + min: 1, }, { name: "Horizontal align", type: "option", - value: [ - "Left", - "Center", - "Right" - ], - defaultIndex: 1 + value: ["Left", "Center", "Right"], + defaultIndex: 1, }, { name: "Vertical align", type: "option", - value: [ - "Top", - "Middle", - "Bottom" - ], - defaultIndex: 1 + value: ["Top", "Middle", "Bottom"], + defaultIndex: 1, }, { name: "Resizing algorithm", @@ -71,15 +68,15 @@ class ContainImage extends Operation { "Bilinear", "Bicubic", "Hermite", - "Bezier" + "Bezier", ], - defaultIndex: 1 + defaultIndex: 1, }, { name: "Opaque background", type: "boolean", - value: true - } + value: true, + }, ]; } @@ -92,20 +89,20 @@ class ContainImage extends Operation { const [width, height, hAlign, vAlign, alg, opaqueBg] = args; const resizeMap = { - "Nearest Neighbour": jimp.RESIZE_NEAREST_NEIGHBOR, - "Bilinear": jimp.RESIZE_BILINEAR, - "Bicubic": jimp.RESIZE_BICUBIC, - "Hermite": jimp.RESIZE_HERMITE, - "Bezier": jimp.RESIZE_BEZIER + "Nearest Neighbour": ResizeStrategy.NEAREST_NEIGHBOR, + Bilinear: ResizeStrategy.BILINEAR, + Bicubic: ResizeStrategy.BICUBIC, + Hermite: ResizeStrategy.HERMITE, + Bezier: ResizeStrategy.BEZIER, }; const alignMap = { - "Left": jimp.HORIZONTAL_ALIGN_LEFT, - "Center": jimp.HORIZONTAL_ALIGN_CENTER, - "Right": jimp.HORIZONTAL_ALIGN_RIGHT, - "Top": jimp.VERTICAL_ALIGN_TOP, - "Middle": jimp.VERTICAL_ALIGN_MIDDLE, - "Bottom": jimp.VERTICAL_ALIGN_BOTTOM + Left: HorizontalAlign.LEFT, + Center: HorizontalAlign.CENTER, + Right: HorizontalAlign.RIGHT, + Top: VerticalAlign.TOP, + Middle: VerticalAlign.MIDDLE, + Bottom: VerticalAlign.BOTTOM, }; if (!isImage(input)) { @@ -114,26 +111,39 @@ class ContainImage extends Operation { let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error loading image. (${err})`); } + const originalMime = image.mime; try { if (isWorkerEnvironment()) self.sendStatusMessage("Containing image..."); - image.contain(width, height, alignMap[hAlign] | alignMap[vAlign], resizeMap[alg]); + image.contain({ + w: width, + h: height, + align: alignMap[hAlign] | alignMap[vAlign], + mode: resizeMap[alg], + }); if (opaqueBg) { - const newImage = await jimp.read(width, height, 0x000000FF); - newImage.blit(image, 0, 0); - image = newImage; + const newImage = new Jimp({ + width, + height, + color: 0x000000ff, + }); + image = newImage.blit({ + src: image, + x: 0, + y: 0, + }); } let imageBuffer; - if (image.getMIME() === "image/gif") { - imageBuffer = await image.getBufferAsync(jimp.MIME_PNG); + if (originalMime === "image/gif") { + imageBuffer = await image.getBuffer(JimpMime.png); } else { - imageBuffer = await image.getBufferAsync(jimp.AUTO); + imageBuffer = await image.getBuffer(originalMime); } return imageBuffer.buffer; } catch (err) { @@ -157,7 +167,6 @@ class ContainImage extends Operation { return `
- Joint Photographic Experts Group (JPEG)
- Portable Network Graphics (PNG)
- Bitmap (BMP)
- Tagged Image File Format (TIFF)
Note: GIF files are supported for input, but cannot be outputted."; + this.description = + "Converts an image between different formats. Supported formats:
- Joint Photographic Experts Group (JPEG)
- Portable Network Graphics (PNG)
- Bitmap (BMP)
- Tagged Image File Format (TIFF)
Note: GIF files are supported for input, but cannot be outputted."; this.infoURL = "https://wikipedia.org/wiki/Image_file_formats"; this.inputType = "ArrayBuffer"; this.outputType = "ArrayBuffer"; @@ -33,39 +32,27 @@ class ConvertImageFormat extends Operation { { name: "Output Format", type: "option", - value: [ - "JPEG", - "PNG", - "BMP", - "TIFF" - ] + value: ["JPEG", "PNG", "BMP", "TIFF"], }, { name: "JPEG Quality", type: "number", value: 80, min: 1, - max: 100 + max: 100, }, { name: "PNG Filter Type", type: "option", - value: [ - "Auto", - "None", - "Sub", - "Up", - "Average", - "Paeth" - ] + value: ["Auto", "None", "Sub", "Up", "Average", "Paeth"], }, { name: "PNG Deflate Level", type: "number", value: 9, min: 0, - max: 9 - } + max: 9, + }, ]; } @@ -77,19 +64,19 @@ class ConvertImageFormat extends Operation { async run(input, args) { const [format, jpegQuality, pngFilterType, pngDeflateLevel] = args; const formatMap = { - "JPEG": jimp.MIME_JPEG, - "PNG": jimp.MIME_PNG, - "BMP": jimp.MIME_BMP, - "TIFF": jimp.MIME_TIFF + JPEG: JimpMime.jpeg, + PNG: JimpMime.png, + BMP: JimpMime.bmp, + TIFF: JimpMime.tiff, }; const pngFilterMap = { - "Auto": jimp.PNG_FILTER_AUTO, - "None": jimp.PNG_FILTER_NONE, - "Sub": jimp.PNG_FILTER_SUB, - "Up": jimp.PNG_FILTER_UP, - "Average": jimp.PNG_FILTER_AVERAGE, - "Paeth": jimp.PNG_FILTER_PATH + Auto: PNGFilterType.AUTO, + None: PNGFilterType.NONE, + Sub: PNGFilterType.SUB, + Up: PNGFilterType.UP, + Average: PNGFilterType.AVERAGE, + Paeth: PNGFilterType.PATH, }; const mime = formatMap[format]; @@ -99,23 +86,30 @@ class ConvertImageFormat extends Operation { } let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error opening image file. (${err})`); } try { - switch (format) { - case "JPEG": - image.quality(jpegQuality); + let buffer; + switch (mime) { + case JimpMime.jpeg: + buffer = await image.getBuffer(mime, { + quality: jpegQuality, + }); break; - case "PNG": - image.filterType(pngFilterMap[pngFilterType]); - image.deflateLevel(pngDeflateLevel); + case JimpMime.png: + buffer = await image.getBuffer(mime, { + filterType: pngFilterMap[pngFilterType], + deflateLevel: pngDeflateLevel, + }); + break; + default: + buffer = await image.getBuffer(mime); break; } - const imageBuffer = await image.getBufferAsync(mime); - return imageBuffer.buffer; + return buffer.buffer; } catch (err) { throw new OperationError(`Error converting image format. (${err})`); } @@ -138,7 +132,6 @@ class ConvertImageFormat extends Operation { return `
Autocrop
Automatically crops same-colour borders from the image.
Autocrop tolerance
A percentage value for the tolerance of colour difference between pixels.
Only autocrop frames
Only crop real frames (all sides must have the same border)
Symmetric autocrop
Force autocrop to be symmetric (top/bottom and left/right are cropped by the same amount)
Autocrop keep border
The number of pixels of border to leave around the image."; + this.description = + "Crops an image to the specified region, or automatically crops edges.
Autocrop
Automatically crops same-colour borders from the image.
Autocrop tolerance
A percentage value for the tolerance of colour difference between pixels.
Only autocrop frames
Only crop real frames (all sides must have the same border)
Symmetric autocrop
Force autocrop to be symmetric (top/bottom and left/right are cropped by the same amount)
Autocrop keep border
The number of pixels of border to leave around the image."; this.infoURL = "https://wikipedia.org/wiki/Cropping_(image)"; this.inputType = "ArrayBuffer"; this.outputType = "ArrayBuffer"; @@ -35,30 +34,30 @@ class CropImage extends Operation { name: "X Position", type: "number", value: 0, - min: 0 + min: 0, }, { name: "Y Position", type: "number", value: 0, - min: 0 + min: 0, }, { name: "Width", type: "number", value: 10, - min: 1 + min: 1, }, { name: "Height", type: "number", value: 10, - min: 1 + min: 1, }, { name: "Autocrop", type: "boolean", - value: false + value: false, }, { name: "Autocrop tolerance (%)", @@ -66,24 +65,24 @@ class CropImage extends Operation { value: 0.02, min: 0, max: 100, - step: 0.01 + step: 0.01, }, { name: "Only autocrop frames", type: "boolean", - value: true + value: true, }, { name: "Symmetric autocrop", type: "boolean", - value: false + value: false, }, { name: "Autocrop keep border (px)", type: "number", value: 0, - min: 0 - } + min: 0, + }, ]; } @@ -93,14 +92,24 @@ class CropImage extends Operation { * @returns {byteArray} */ async run(input, args) { - const [xPos, yPos, width, height, autocrop, autoTolerance, autoFrames, autoSymmetric, autoBorder] = args; + const [ + xPos, + yPos, + width, + height, + autocrop, + autoTolerance, + autoFrames, + autoSymmetric, + autoBorder, + ] = args; if (!isImage(input)) { throw new OperationError("Invalid file type."); } let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error loading image. (${err})`); } @@ -109,20 +118,25 @@ class CropImage extends Operation { self.sendStatusMessage("Cropping image..."); if (autocrop) { image.autocrop({ - tolerance: (autoTolerance / 100), + tolerance: autoTolerance / 100, cropOnlyFrames: autoFrames, cropSymmetric: autoSymmetric, - leaveBorder: autoBorder + leaveBorder: autoBorder, }); } else { - image.crop(xPos, yPos, width, height); + image.crop({ + x: xPos, + y: yPos, + w: width, + h: height, + }); } let imageBuffer; - if (image.getMIME() === "image/gif") { - imageBuffer = await image.getBufferAsync(jimp.MIME_PNG); + if (image.mime === "image/gif") { + imageBuffer = await image.getBuffer(JimpMime.png); } else { - imageBuffer = await image.getBufferAsync(jimp.AUTO); + imageBuffer = await image.getBuffer(image.mime); } return imageBuffer.buffer; } catch (err) { @@ -146,7 +160,6 @@ class CropImage extends Operation { return `
Key: DES uses a key length of 8 bytes (64 bits).
Triple DES uses a key length of 24 bytes (192 bits).
IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
Padding: In CBC and ECB mode, PKCS#7 padding will be used as a default."; + this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.
Key: DES uses a key length of 8 bytes (64 bits).
IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
Padding: In CBC and ECB mode, PKCS#7 padding will be used as a default."; this.infoURL = "https://wikipedia.org/wiki/Data_Encryption_Standard"; this.inputType = "string"; this.outputType = "string"; @@ -72,8 +72,7 @@ class DESDecrypt extends Operation { if (key.length !== 8) { throw new OperationError(`Invalid key length: ${key.length} bytes -DES uses a key length of 8 bytes (64 bits). -Triple DES uses a key length of 24 bytes (192 bits).`); +DES uses a key length of 8 bytes (64 bits).`); } if (iv.length !== 8 && mode !== "ECB") { throw new OperationError(`Invalid IV length: ${iv.length} bytes diff --git a/src/core/operations/DESEncrypt.mjs b/src/core/operations/DESEncrypt.mjs index 9472abe8..28d6202a 100644 --- a/src/core/operations/DESEncrypt.mjs +++ b/src/core/operations/DESEncrypt.mjs @@ -22,7 +22,7 @@ class DESEncrypt extends Operation { this.name = "DES Encrypt"; this.module = "Ciphers"; - this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.
Key: DES uses a key length of 8 bytes (64 bits).
Triple DES uses a key length of 24 bytes (192 bits).
You can generate a password-based key using one of the KDF operations.
IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
Padding: In CBC and ECB mode, PKCS#7 padding will be used."; + this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.
Key: DES uses a key length of 8 bytes (64 bits).
You can generate a password-based key using one of the KDF operations.
IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
Padding: In CBC and ECB mode, PKCS#7 padding will be used."; this.infoURL = "https://wikipedia.org/wiki/Data_Encryption_Standard"; this.inputType = "string"; this.outputType = "string"; @@ -70,8 +70,7 @@ class DESEncrypt extends Operation { if (key.length !== 8) { throw new OperationError(`Invalid key length: ${key.length} bytes -DES uses a key length of 8 bytes (64 bits). -Triple DES uses a key length of 24 bytes (192 bits).`); +DES uses a key length of 8 bytes (64 bits).`); } if (iv.length !== 8 && mode !== "ECB") { throw new OperationError(`Invalid IV length: ${iv.length} bytes diff --git a/src/core/operations/DNSOverHTTPS.mjs b/src/core/operations/DNSOverHTTPS.mjs index 4dde2f13..87381226 100644 --- a/src/core/operations/DNSOverHTTPS.mjs +++ b/src/core/operations/DNSOverHTTPS.mjs @@ -51,10 +51,27 @@ class DNSOverHTTPS extends Operation { value: [ "A", "AAAA", - "TXT", - "MX", + "ANAME", + "CERT", + "CNAME", "DNSKEY", - "NS" + "HTTPS", + "IPSECKEY", + "LOC", + "MX", + "NS", + "OPENPGPKEY", + "PTR", + "RRSIG", + "SIG", + "SOA", + "SPF", + "SRV", + "SSHFP", + "TA", + "TXT", + "URI", + "ANY" ] }, { diff --git a/src/core/operations/DateTimeDelta.mjs b/src/core/operations/DateTimeDelta.mjs new file mode 100644 index 00000000..7f82cf01 --- /dev/null +++ b/src/core/operations/DateTimeDelta.mjs @@ -0,0 +1,107 @@ +/** + * @author tomgond [tom.gonda@gmail.com] + * @copyright Crown Copyright 2024 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import moment from "moment-timezone"; +import {DATETIME_FORMATS, FORMAT_EXAMPLES} from "../lib/DateTime.mjs"; + +/** + * DateTime Delta operation + */ +class DateTimeDelta extends Operation { + + /** + * DateTimeDelta constructor + */ + constructor() { + super(); + + this.name = "DateTime Delta"; + this.module = "Default"; + this.description = "Calculates a new DateTime value given an input DateTime value and a time difference (delta) from the input DateTime value."; + this.inputType = "string"; + this.outputType = "html"; + this.args = [ + { + "name": "Built in formats", + "type": "populateOption", + "value": DATETIME_FORMATS, + "target": 1 + }, + { + "name": "Input format string", + "type": "binaryString", + "value": "DD/MM/YYYY HH:mm:ss" + }, + { + "name": "Time Operation", + "type": "option", + "value": ["Add", "Subtract"] + }, + { + "name": "Days", + "type": "number", + "value": 0 + }, + { + "name": "Hours", + "type": "number", + "value": 0 + }, + { + "name": "Minutes", + "type": "number", + "value": 0 + }, + { + "name": "Seconds", + "type": "number", + "value": 0 + } + + ]; + } + + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const inputTimezone = "UTC"; + const inputFormat = args[1]; + const operationType = args[2]; + const daysDelta = args[3]; + const hoursDelta = args[4]; + const minutesDelta = args[5]; + const secondsDelta = args[6]; + let date = ""; + + try { + date = moment.tz(input, inputFormat, inputTimezone); + if (!date || date.format() === "Invalid date") throw Error; + } catch (err) { + return `Invalid format.\n\n${FORMAT_EXAMPLES}`; + } + let newDate; + if (operationType === "Add") { + newDate = date.add(daysDelta, "days") + .add(hoursDelta, "hours") + .add(minutesDelta, "minutes") + .add(secondsDelta, "seconds"); + + } else { + newDate = date.add(-daysDelta, "days") + .add(-hoursDelta, "hours") + .add(-minutesDelta, "minutes") + .add(-secondsDelta, "seconds"); + } + return newDate.tz(inputTimezone).format(inputFormat.replace(/[<>]/g, "")); + } +} + +export default DateTimeDelta; diff --git a/src/core/operations/DecodeText.mjs b/src/core/operations/DecodeText.mjs index 9b01b79f..0fc9d2b5 100644 --- a/src/core/operations/DecodeText.mjs +++ b/src/core/operations/DecodeText.mjs @@ -6,7 +6,7 @@ import Operation from "../Operation.mjs"; import cptable from "codepage"; -import {IO_FORMAT} from "../lib/ChrEnc.mjs"; +import {CHR_ENC_CODE_PAGES} from "../lib/ChrEnc.mjs"; /** * Decode text operation @@ -26,7 +26,7 @@ class DecodeText extends Operation { "
", "Supported charsets are:", "
- ",
- Object.keys(IO_FORMAT).map(e => `
- ${e} `).join("\n"), + Object.keys(CHR_ENC_CODE_PAGES).map(e => `
- ${e} `).join("\n"), "
Supports ARM (32-bit), Thumb, and ARM64 (AArch64) architectures using the Capstone disassembly framework.
Input should be in hexadecimal."; + this.infoURL = "https://wikipedia.org/wiki/ARM_architecture_family"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Architecture", + "type": "option", + "value": ["ARM (32-bit)", "ARM64 (AArch64)"] + }, + { + "name": "Mode", + "type": "option", + "value": ["ARM", "Thumb", "Thumb + Cortex-M", "ARMv8"] + }, + { + "name": "Endianness", + "type": "option", + "value": ["Little Endian", "Big Endian"] + }, + { + "name": "Starting address (hex)", + "type": "number", + "value": 0 + }, + { + "name": "Show instruction hex", + "type": "boolean", + "value": true + }, + { + "name": "Show instruction position", + "type": "boolean", + "value": true + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + async run(input, args) { + const [ + architecture, + mode, + endianness, + startAddress, + showHex, + showPosition + ] = args; + + // Remove whitespace from input + const hexInput = input.replace(/\s/g, ""); + + // Validate hex input + if (!/^[0-9a-fA-F]*$/.test(hexInput)) { + throw new OperationError("Invalid hexadecimal input. Please provide valid hex characters only."); + } + + if (hexInput.length === 0) { + return ""; + } + + if (hexInput.length % 2 !== 0) { + throw new OperationError("Invalid hexadecimal input. Length must be even."); + } + + // Convert hex string to byte array + const bytes = []; + for (let i = 0; i < hexInput.length; i += 2) { + bytes.push(parseInt(hexInput.substr(i, 2), 16)); + } + + // Determine architecture constant + let arch; + if (architecture === "ARM64 (AArch64)") { + arch = cs.ARCH_ARM64; + } else { + arch = cs.ARCH_ARM; + } + + // Determine mode constant + let modeValue = cs.MODE_LITTLE_ENDIAN; + + if (architecture === "ARM (32-bit)") { + switch (mode) { + case "ARM": + modeValue = cs.MODE_ARM; + break; + case "Thumb": + modeValue = cs.MODE_THUMB; + break; + case "Thumb + Cortex-M": + modeValue = cs.MODE_THUMB | cs.MODE_MCLASS; + break; + case "ARMv8": + modeValue = cs.MODE_ARM | cs.MODE_V8; + break; + default: + modeValue = cs.MODE_ARM; + } + } else { + // ARM64 only has one mode (ARM mode is default for ARM64) + modeValue = cs.MODE_ARM; + } + + // Add endianness + if (endianness === "Big Endian") { + modeValue |= cs.MODE_BIG_ENDIAN; + } + + if (isWorkerEnvironment()) { + self.sendStatusMessage("Disassembling..."); + } + + let disassembler; + try { + disassembler = new cs.Capstone(arch, modeValue); + } catch (e) { + throw new OperationError(`Failed to initialise Capstone disassembler: ${e}`); + } + + let instructions; + try { + instructions = disassembler.disasm(bytes, startAddress); + } catch (e) { + disassembler.close(); + // Check if it's a "no valid instructions" error (code 0 means OK but nothing decoded) + if (e && e.includes && e.includes("code 0:")) { + throw new OperationError(`No valid ${architecture} instructions found in input. The bytes may be for a different architecture or mode.`); + } + throw new OperationError(`Disassembly failed: ${e}`); + } + + // Format output + const output = []; + for (const insn of instructions) { + let line = ""; + + if (showPosition) { + // Format address as hex with 0x prefix + const addrHex = "0x" + insn.address.toString(16).padStart(8, "0"); + line += addrHex + " "; + } + + if (showHex) { + // Format instruction bytes as hex + const bytesHex = insn.bytes.map(b => b.toString(16).padStart(2, "0")).join(""); + line += bytesHex.padEnd(16, " ") + " "; + } + + line += insn.mnemonic; + if (insn.op_str) { + line += " " + insn.op_str; + } + + output.push(line); + } + + disassembler.close(); + + return output.join("\n"); + } + +} + +export default DisassembleARM; diff --git a/src/core/operations/DitherImage.mjs b/src/core/operations/DitherImage.mjs index eefa38c2..f21c1f88 100644 --- a/src/core/operations/DitherImage.mjs +++ b/src/core/operations/DitherImage.mjs @@ -9,14 +9,12 @@ import OperationError from "../errors/OperationError.mjs"; import { isImage } from "../lib/FileType.mjs"; import { toBase64 } from "../lib/Base64.mjs"; import { isWorkerEnvironment } from "../Utils.mjs"; -import jimplib from "jimp/es/index.js"; -const jimp = jimplib.default ? jimplib.default : jimplib; +import { Jimp, JimpMime } from "jimp"; /** * Image Dither operation */ class DitherImage extends Operation { - /** * DitherImage constructor */ @@ -45,24 +43,26 @@ class DitherImage extends Operation { let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error loading image. (${err})`); } try { if (isWorkerEnvironment()) self.sendStatusMessage("Applying dither to image..."); - image.dither565(); + image.dither(); let imageBuffer; - if (image.getMIME() === "image/gif") { - imageBuffer = await image.getBufferAsync(jimp.MIME_PNG); + if (image.mime === "image/gif") { + imageBuffer = await image.getBuffer(JimpMime.png); } else { - imageBuffer = await image.getBufferAsync(jimp.AUTO); + imageBuffer = await image.getBuffer(image.mime); } return imageBuffer.buffer; } catch (err) { - throw new OperationError(`Error applying dither to image. (${err})`); + throw new OperationError( + `Error applying dither to image. (${err})`, + ); } } @@ -82,7 +82,6 @@ class DitherImage extends Operation { return `
", "Supported charsets are:", "
- ",
- Object.keys(IO_FORMAT).map(e => `
- ${e} `).join("\n"), + Object.keys(CHR_ENC_CODE_PAGES).map(e => `
- ${e} `).join("\n"), "
`; } diff --git a/src/core/operations/ParseEthernetFrame.mjs b/src/core/operations/ParseEthernetFrame.mjs new file mode 100644 index 00000000..0be5e1a4 --- /dev/null +++ b/src/core/operations/ParseEthernetFrame.mjs @@ -0,0 +1,112 @@ +/** + * @author tedk [tedk@ted.do] + * @copyright Crown Copyright 2024 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import OperationError from "../errors/OperationError.mjs"; +import Utils from "../Utils.mjs"; +import {fromHex, toHex} from "../lib/Hex.mjs"; + +/** + * Parse Ethernet frame operation + */ +class ParseEthernetFrame extends Operation { + + /** + * ParseEthernetFrame constructor + */ + constructor() { + super(); + + this.name = "Parse Ethernet frame"; + this.module = "Default"; + this.description = "Parses an Ethernet frame and either shows the deduced values (Source and destination MAC, VLANs) or returns the packet data.
Good for use in conjunction with the Parse IPv4, and Parse TCP/UDP recipes."; + this.infoURL = "https://en.wikipedia.org/wiki/Ethernet_frame#Frame_%E2%80%93_data_link_layer"; + this.inputType = "string"; + this.outputType = "html"; + this.args = [ + { + name: "Input type", + type: "option", + value: [ + "Raw", "Hex" + ], + defaultIndex: 0, + }, + { + name: "Return type", + type: "option", + value: [ + "Text output", "Packet data", "Packet data (hex)", + ], + defaultIndex: 0, + } + ]; + } + + + /** + * @param {string} input + * @param {Object[]} args + * @returns {html} + */ + run(input, args) { + const format = args[0]; + const outputFormat = args[1]; + + if (format === "Hex") { + input = fromHex(input); + } else if (format === "Raw") { + input = new Uint8Array(Utils.strToArrayBuffer(input)); + } else { + throw new OperationError("Invalid input format selected."); + } + + const destinationMac = input.slice(0, 6); + const sourceMac = input.slice(6, 12); + + let offset = 12; + const vlans = []; + + while (offset < input.length) { + const ethType = Utils.byteArrayToChars(input.slice(offset, offset+2)); + offset += 2; + + if (ethType === "\x81\x00" || ethType === "\x88\xA8") { + // Parse the VLAN tag: + // [0000] 0000 0000 0000 + // ^^^ PRIO - Ignored + // ^ DEI - Ignored + // ^^^^ ^^^^ ^^^^ VLAN ID + const vlanTag = input.slice(offset, offset+2); + vlans.push(((vlanTag[0] & 0b00001111) << 8) | vlanTag[1]); + + offset += 2; + } else { + break; + } + } + + const packetData = input.slice(offset); + + if (outputFormat === "Packet data") { + return Utils.byteArrayToChars(packetData); + } else if (outputFormat === "Packet data (hex)") { + return toHex(packetData); + } else if (outputFormat === "Text output") { + let retval = `Source MAC: ${toHex(sourceMac, ":")}\nDestination MAC: ${toHex(destinationMac, ":")}\n`; + if (vlans.length > 0) { + retval += `VLAN: ${vlans.join(", ")}\n`; + } + retval += `Data:\n${toHex(packetData)}`; + return retval; + } + + } + + +} + +export default ParseEthernetFrame; diff --git a/src/core/operations/ParseIPv4Header.mjs b/src/core/operations/ParseIPv4Header.mjs index 304ba0c0..4eed5d46 100644 --- a/src/core/operations/ParseIPv4Header.mjs +++ b/src/core/operations/ParseIPv4Header.mjs @@ -33,6 +33,12 @@ class ParseIPv4Header extends Operation { "name": "Input format", "type": "option", "value": ["Hex", "Raw"] + }, + { + "name": "Output format", + "type": "option", + "value": ["Table", "Data (hex)", "Data (raw)"], + defaultIndex: 0, } ]; } @@ -44,12 +50,14 @@ class ParseIPv4Header extends Operation { */ run(input, args) { const format = args[0]; + const outputFormat = args[1]; + let output; if (format === "Hex") { input = fromHex(input); } else if (format === "Raw") { - input = Utils.strToByteArray(input); + input = new Uint8Array(Utils.strToArrayBuffer(input)); } else { throw new OperationError("Unrecognised input format."); } @@ -98,7 +106,10 @@ class ParseIPv4Header extends Operation { checksumResult = givenChecksum + " (incorrect, should be " + correctChecksum + ")"; } - output = `
| Field | Value |
|---|
| Field | Value |
|---|---|
| Version | ${version} |
| Internet Header Length (IHL) | ${ihl} (${ihl * 4} bytes) |
| Differentiated Services Code Point (DSCP) | ${dscp} |
| Protocol | ${protocol}, ${protocolInfo.protocol} (${protocolInfo.keyword}) |
| Header checksum | ${checksumResult} |
| Source IP address | ${ipv4ToStr(srcIP)} |
| Destination IP address | ${ipv4ToStr(dstIP)} |
| Destination IP address | ${ipv4ToStr(dstIP)} |
| Data (hex) | ${toHex(data)} |
| Options | ${toHex(options)} |
| Options | ${toHex(options)} |
Normalise Image
Attempts to normalise the image before parsing it to improve detection of a QR code."; + this.description = + "Reads an image file and attempts to detect and read a Quick Response (QR) code from the image.
Normalise Image
Attempts to normalise the image before parsing it to improve detection of a QR code."; this.infoURL = "https://wikipedia.org/wiki/QR_code"; this.inputType = "ArrayBuffer"; this.outputType = "string"; this.args = [ { - "name": "Normalise image", - "type": "boolean", - "value": false - } + name: "Normalise image", + type: "boolean", + value: false, + }, ]; this.checks = [ { - "pattern": "^(?:\\xff\\xd8\\xff|\\x89\\x50\\x4e\\x47|\\x47\\x49\\x46|.{8}\\x57\\x45\\x42\\x50|\\x42\\x4d)", - "flags": "", - "args": [false], - "useful": true - } + pattern: + "^(?:\\xff\\xd8\\xff|\\x89\\x50\\x4e\\x47|\\x47\\x49\\x46|.{8}\\x57\\x45\\x42\\x50|\\x42\\x4d)", + flags: "", + args: [false], + useful: true, + }, ]; } @@ -54,9 +55,8 @@ class ParseQRCode extends Operation { if (!isImage(input)) { throw new OperationError("Invalid file type."); } - return await parseQrCode(input, normalise); + return parseQrCode(input, normalise); } - } export default ParseQRCode; diff --git a/src/core/operations/ParseSSHHostKey.mjs b/src/core/operations/ParseSSHHostKey.mjs index 8a3bf5da..f1a1f58c 100644 --- a/src/core/operations/ParseSSHHostKey.mjs +++ b/src/core/operations/ParseSSHHostKey.mjs @@ -23,7 +23,7 @@ class ParseSSHHostKey extends Operation { this.name = "Parse SSH Host Key"; this.module = "Default"; - this.description = "Parses a SSH host key and extracts fields from it.
The key type can be:
- ssh-rsa
- ssh-dss
- ecdsa-sha2
The key type can be:
- ssh-rsa
- ssh-dss
- ecdsa-sha2
- ssh-ed25519
Generates random integers within a specified range using the browser's built-in
crypto.getRandomValues() method if available.The supported range of integers is from
-(2^53 - 1) to (2^53 - 1).";
+ this.infoURL = "https://wikipedia.org/wiki/Pseudorandom_number_generator";
+ this.inputType = "string";
+ this.outputType = "string";
+ this.args = [
+ {
+ "name": "Number of Integers",
+ "type": "number",
+ "value": 1,
+ "min": 1
+ },
+ {
+ "name": "Min Value",
+ "type": "number",
+ "value": 0,
+ "min": Number.MIN_SAFE_INTEGER,
+ "max": Number.MAX_SAFE_INTEGER
+ },
+ {
+ "name": "Max Value",
+ "type": "number",
+ "value": 99,
+ "min": Number.MIN_SAFE_INTEGER,
+ "max": Number.MAX_SAFE_INTEGER
+ },
+ {
+ "name": "Delimiter",
+ "type": "option",
+ "value": DELIM_OPTIONS
+ },
+ {
+ "name": "Output",
+ "type": "option",
+ "value": ["Raw", "Hex", "Decimal"]
+ }
+ ];
+
+ // not using BigUint64Array to avoid BigInt handling overhead
+ this.randomBuffer = new Uint32Array(PseudoRandomIntegerGenerator.BUFFER_SIZE);
+ this.randomBufferOffset = PseudoRandomIntegerGenerator.BUFFER_SIZE;
+ }
+
+ /**
+ * @param {string} input
+ * @param {Object[]} args
+ * @returns {string}
+ */
+ run(input, args) {
+ const [numInts, minInt, maxInt, delimiter, outputType] = args;
+
+ if (minInt === null || maxInt === null) return "";
+
+ const min = Math.ceil(minInt);
+ const max = Math.floor(maxInt);
+ const delim = Utils.charRep(delimiter || "Space");
+
+ if (!Number.isSafeInteger(min) || !Number.isSafeInteger(max)) {
+ throw new OperationError("Min and Max must be between `-(2^53 - 1)` and `2^53 - 1`.");
+ }
+ if (min > max) {
+ throw new OperationError("Min cannot be larger than Max.");
+ }
+ const range = max - min + 1; // inclusive range
+ if (range > PseudoRandomIntegerGenerator.MAX_RANGE) {
+ throw new OperationError("Range between Min and Max cannot be larger than `2^53`");
+ }
+
+ // as large as possible while divisible by range
+ const rejectionThreshold = PseudoRandomIntegerGenerator.MAX_RANGE - (PseudoRandomIntegerGenerator.MAX_RANGE % range);
+ const output = [];
+ for (let i = 0; i < numInts; i++) {
+ const result = this._generateRandomValue(rejectionThreshold);
+ const intValue = min + (result % range);
+
+ switch (outputType) {
+ case "Hex":
+ output.push(intValue.toString(16));
+ break;
+ case "Decimal":
+ output.push(intValue.toString(10));
+ break;
+ case "Raw":
+ default:
+ output.push(Utils.chr(intValue));
+ }
+ }
+
+ if (outputType === "Raw") {
+ return output.join("");
+ }
+ return output.join(delim);
+ }
+
+ /**
+ * Generate a random value, result will be less than the rejection threshold (exclusive).
+ *
+ * @param {number} rejectionThreshold
+ * @returns {number}
+ */
+ _generateRandomValue(rejectionThreshold) {
+ let result;
+ do {
+ if (this.randomBufferOffset + 2 > this.randomBuffer.length) {
+ this._resetRandomBuffer();
+ }
+ // stitching a 53 bit number; not using BigUint64Array to avoid BigInt handling overhead
+ result = (this.randomBuffer[this.randomBufferOffset++] & 0x1f_ffff) * 0x1_0000_0000 +
+ this.randomBuffer[this.randomBufferOffset++];
+ } while (result >= rejectionThreshold);
+
+ return result;
+ }
+
+ /**
+ * Fill random buffer with new random values and rseet the offset.
+ */
+ _resetRandomBuffer() {
+ if (isWorkerEnvironment() && self.crypto) {
+ self.crypto.getRandomValues(this.randomBuffer);
+ } else {
+ const bytes = forge.random.getBytesSync(this.randomBuffer.length * 4);
+ for (let j = 0; j < this.randomBuffer.length; j++) {
+ this.randomBuffer[j] = (bytes.charCodeAt(j * 4) << 24) |
+ (bytes.charCodeAt(j * 4 + 1) << 16) |
+ (bytes.charCodeAt(j * 4 + 2) << 8) |
+ bytes.charCodeAt(j * 4 + 3);
+ }
+ }
+ this.randomBufferOffset = 0;
+ }
+
+}
+
+export default PseudoRandomIntegerGenerator;
diff --git a/src/core/operations/PseudoRandomNumberGenerator.mjs b/src/core/operations/PseudoRandomNumberGenerator.mjs
index 033aa859..53150566 100644
--- a/src/core/operations/PseudoRandomNumberGenerator.mjs
+++ b/src/core/operations/PseudoRandomNumberGenerator.mjs
@@ -52,8 +52,12 @@ class PseudoRandomNumberGenerator extends Operation {
let bytes;
if (isWorkerEnvironment() && self.crypto) {
- bytes = self.crypto.getRandomValues(new Uint8Array(numBytes));
- bytes = Utils.arrayBufferToStr(bytes.buffer);
+ bytes = new ArrayBuffer(numBytes);
+ const CHUNK_SIZE = 65536;
+ for (let i = 0; i < numBytes; i += CHUNK_SIZE) {
+ self.crypto.getRandomValues(new Uint8Array(bytes, i, Math.min(numBytes - i, CHUNK_SIZE)));
+ }
+ bytes = Utils.arrayBufferToStr(bytes);
} else {
bytes = forge.random.getBytesSync(numBytes);
}
diff --git a/src/core/operations/PubKeyFromCert.mjs b/src/core/operations/PubKeyFromCert.mjs
new file mode 100644
index 00000000..0233b04a
--- /dev/null
+++ b/src/core/operations/PubKeyFromCert.mjs
@@ -0,0 +1,68 @@
+/**
+ * @author cplussharp
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import r from "jsrsasign";
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Public Key from Certificate operation
+ */
+class PubKeyFromCert extends Operation {
+
+ /**
+ * PubKeyFromCert constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "Public Key from Certificate";
+ this.module = "PublicKey";
+ this.description = "Extracts the Public Key from a Certificate.";
+ this.infoURL = "https://en.wikipedia.org/wiki/X.509";
+ this.inputType = "string";
+ this.outputType = "string";
+ this.args = [];
+ this.checks = [];
+ }
+
+ /**
+ * @param {string} input
+ * @param {Object[]} args
+ * @returns {string}
+ */
+ run(input, args) {
+ let output = "";
+ let match;
+ const regex = /-----BEGIN CERTIFICATE-----/g;
+ while ((match = regex.exec(input)) !== null) {
+ // find corresponding end tag
+ const indexBase64 = match.index + match[0].length;
+ const footer = "-----END CERTIFICATE-----";
+ const indexFooter = input.indexOf(footer, indexBase64);
+ if (indexFooter === -1) {
+ throw new OperationError(`PEM footer '${footer}' not found`);
+ }
+
+ const certPem = input.substring(match.index, indexFooter + footer.length);
+ const cert = new r.X509();
+ cert.readCertPEM(certPem);
+ let pubKey;
+ try {
+ pubKey = cert.getPublicKey();
+ } catch {
+ throw new OperationError("Unsupported public key type");
+ }
+ const pubKeyPem = r.KEYUTIL.getPEM(pubKey);
+
+ // PEM ends with '\n', so a new key always starts on a new line
+ output += pubKeyPem;
+ }
+ return output;
+ }
+}
+
+export default PubKeyFromCert;
diff --git a/src/core/operations/PubKeyFromPrivKey.mjs b/src/core/operations/PubKeyFromPrivKey.mjs
new file mode 100644
index 00000000..5a08882b
--- /dev/null
+++ b/src/core/operations/PubKeyFromPrivKey.mjs
@@ -0,0 +1,82 @@
+/**
+ * @author cplussharp
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import r from "jsrsasign";
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Public Key from Private Key operation
+ */
+class PubKeyFromPrivKey extends Operation {
+
+ /**
+ * PubKeyFromPrivKey constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "Public Key from Private Key";
+ this.module = "PublicKey";
+ this.description = "Extracts the Public Key from a Private Key.";
+ this.infoURL = "https://en.wikipedia.org/wiki/PKCS_8";
+ this.inputType = "string";
+ this.outputType = "string";
+ this.args = [];
+ this.checks = [];
+ }
+
+ /**
+ * @param {string} input
+ * @param {Object[]} args
+ * @returns {string}
+ */
+ run(input, args) {
+ let output = "";
+ let match;
+ const regex = /-----BEGIN ((RSA |EC |DSA )?PRIVATE KEY)-----/g;
+ while ((match = regex.exec(input)) !== null) {
+ // find corresponding end tag
+ const indexBase64 = match.index + match[0].length;
+ const footer = `-----END ${match[1]}-----`;
+ const indexFooter = input.indexOf(footer, indexBase64);
+ if (indexFooter === -1) {
+ throw new OperationError(`PEM footer '${footer}' not found`);
+ }
+
+ const privKeyPem = input.substring(match.index, indexFooter + footer.length);
+ let privKey;
+ try {
+ privKey = r.KEYUTIL.getKey(privKeyPem);
+ } catch (err) {
+ throw new OperationError(`Unsupported key type: ${err}`);
+ }
+ let pubKey;
+ if (privKey.type && privKey.type === "EC") {
+ pubKey = new r.KJUR.crypto.ECDSA({ curve: privKey.curve });
+ pubKey.setPublicKeyHex(privKey.generatePublicKeyHex());
+ } else if (privKey.type && privKey.type === "DSA") {
+ if (!privKey.y) {
+ throw new OperationError(`DSA Private Key in PKCS#8 is not supported`);
+ }
+ pubKey = new r.KJUR.crypto.DSA();
+ pubKey.setPublic(privKey.p, privKey.q, privKey.g, privKey.y);
+ } else if (privKey.n && privKey.e) {
+ pubKey = new r.RSAKey();
+ pubKey.setPublic(privKey.n, privKey.e);
+ } else {
+ throw new OperationError(`Unsupported key type`);
+ }
+ const pubKeyPem = r.KEYUTIL.getPEM(pubKey);
+
+ // PEM ends with '\n', so a new key always starts on a new line
+ output += pubKeyPem;
+ }
+ return output;
+ }
+}
+
+export default PubKeyFromPrivKey;
diff --git a/src/core/operations/RAKE.mjs b/src/core/operations/RAKE.mjs
new file mode 100644
index 00000000..1470f5f0
--- /dev/null
+++ b/src/core/operations/RAKE.mjs
@@ -0,0 +1,144 @@
+/**
+ * @author sw5678
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * RAKE operation
+ */
+class RAKE extends Operation {
+
+ /**
+ * RAKE constructor
+ */
+ constructor() {
+ super();
+
+ this.name = "RAKE";
+ this.module = "Default";
+ this.description = [
+ "Rapid Keyword Extraction (RAKE)",
+ "", + "RAKE is a domain-independent keyword extraction algorithm in Natural Language Processing.", + "
", + "The list of stop words are from the NLTK python package", + ].join("\n"); + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + name: "Word Delimiter (Regex)", + type: "text", + value: "\\s" + }, + { + name: "Sentence Delimiter (Regex)", + type: "text", + value: "\\.\\s|\\n" + }, + { + name: "Stop Words", + type: "text", + value: "i,me,my,myself,we,our,ours,ourselves,you,you're,you've,you'll,you'd,your,yours,yourself,yourselves,he,him,his,himself,she,she's,her,hers,herself,it,it's,its,itsef,they,them,their,theirs,themselves,what,which,who,whom,this,that,that'll,these,those,am,is,are,was,were,be,been,being,have,has,had,having,do,does',did,doing,a,an,the,and,but,if,or,because,as,until,while,of,at,by,for,with,about,against,between,into,through,during,before,after,above,below,to,from,up,down,in,out,on,off,over,under,again,further,then,once,here,there,when,where,why,how,all,any,both,each,few,more,most,other,some,such,no,nor,not,only,own,same,so,than,too,very,s,t,can,will,just,don,don't,should,should've,now,d,ll,m,o,re,ve,y,ain,aren,aren't,couldn,couldn't,didn,didn't,doesn,doesn't,hadn,hadn't,hasn,hasn't,haven,haven't,isn,isn't,ma,mightn,mightn't,mustn,mustn't,needn,needn't,shan,shan't,shouldn,shouldn't,wasn,wasn't,weren,weren't,won,won't,wouldn,wouldn't" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + + // Get delimiter regexs + const wordDelim = new RegExp(args[0], "g"); + const sentDelim = new RegExp(args[1], "g"); + + // Deduplicate the stop words and add the empty string + const stopWords = args[2].toLowerCase().replace(/ /g, "").split(",").unique(); + stopWords.push(""); + + // Lower case input and remove start and ending whitespace + input = input.toLowerCase().trim(); + + // Get tokens, token count, and phrases + const tokens = []; + const wordFrequencies = []; + let phrases = []; + + // Build up list of phrases and token counts + const sentences = input.split(sentDelim); + for (const sent of sentences) { + + // Split sentence into words + const splitSent = sent.split(wordDelim); + let startIndex = 0; + + for (let i = 0; i < splitSent.length; i++) { + const token = splitSent[i]; + if (stopWords.includes(token)) { + // If token is stop word then split to create phrase + phrases.push(splitSent.slice(startIndex, i)); + startIndex = i + 1; + } else { + // If token is not a stop word add to the count of the list of words + if (tokens.includes(token)) { + wordFrequencies[tokens.indexOf(token)]+=1; + } else { + tokens.push(token); + wordFrequencies.push(1); + } + } + } + phrases.push(splitSent.slice(startIndex)); + } + + // remove empty phrases + phrases = phrases.filter(subArray => subArray.length > 0); + + // Remove duplicate phrases + phrases = phrases.unique(); + + // Generate word_degree_matrix and populate + const wordDegreeMatrix = Array(tokens.length).fill().map(() => Array(tokens.length).fill(0)); + for (const phrase of phrases) { + for (const word1 of phrase) { + for (const word2 of phrase) { + wordDegreeMatrix[tokens.indexOf(word1)][tokens.indexOf(word2)]++; + } + } + } + + // Calculate degree score for each token + const degreeScores = Array(tokens.length).fill(0); + for (let i=0; i
RC6 is parameterised as RC6-w/r/b where w is word size in bits (any multiple of 8 from 8-256), r is the number of rounds (1-255), and b is the key length in bytes. The standard AES submission uses w=32, r=20. Common word sizes: 8, 16, 32 (standard), 64, 128.
IV: The Initialisation Vector should be 4*w/8 bytes (e.g. 16 bytes for w=32). If not entered, it will default to null bytes.
Padding: In CBC and ECB mode, the PKCS#7 padding scheme is used."; + this.infoURL = "https://wikipedia.org/wiki/RC6"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Mode", + "type": "option", + "value": ["CBC", "CFB", "OFB", "CTR", "ECB"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Raw", "Hex"] + }, + { + "name": "Padding", + "type": "option", + "value": ["PKCS5", "NO", "ZERO", "RANDOM", "BIT"] + }, + { + "name": "Word Size", + "type": "number", + "value": 32, + "min": 8, + "max": 256, + "step": 8 + }, + { + "name": "Rounds", + "type": "number", + "value": 20, + "min": 1, + "max": 255 + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string, args[0].option), + iv = Utils.convertToByteArray(args[1].string, args[1].option), + [,, mode, inputType, outputType, padding, wordSize, rounds] = args; + + // Validate word size + if (!Number.isInteger(wordSize) || wordSize < 8 || wordSize > 256 || wordSize % 8 !== 0) + throw new OperationError(`Invalid word size: ${wordSize}. Must be a multiple of 8 between 8 and 256.`); + + const blockSize = getBlockSize(wordSize); + const defaultRounds = getDefaultRounds(wordSize); + + if (iv.length !== blockSize && iv.length !== 0 && mode !== "ECB") + throw new OperationError(`Invalid IV length: ${iv.length} bytes + +RC6-${wordSize} uses an IV length of ${blockSize} bytes (${blockSize * 8} bits). +Make sure you have specified the type correctly (e.g. Hex vs UTF8).`); + + if (!Number.isInteger(rounds) || rounds < 1 || rounds > 255) + throw new OperationError(`Invalid number of rounds: ${rounds} + +Rounds must be an integer between 1 and 255. Standard for w=${wordSize} is ${defaultRounds}.`); + + // Default IV to null bytes if empty (like AES) + const actualIv = iv.length === 0 ? new Array(blockSize).fill(0) : iv; + + input = Utils.convertToByteArray(input, inputType); + const output = decryptRC6(input, key, actualIv, mode, padding, rounds, wordSize); + return outputType === "Hex" ? toHex(output, "") : Utils.byteArrayToUtf8(output); + } + +} + +export default RC6Decrypt; diff --git a/src/core/operations/RC6Encrypt.mjs b/src/core/operations/RC6Encrypt.mjs new file mode 100644 index 00000000..d5ad6d7f --- /dev/null +++ b/src/core/operations/RC6Encrypt.mjs @@ -0,0 +1,119 @@ +/** + * @author Medjedtxm + * @copyright Crown Copyright 2026 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import Utils from "../Utils.mjs"; +import OperationError from "../errors/OperationError.mjs"; +import { toHex } from "../lib/Hex.mjs"; +import { encryptRC6, getBlockSize, getDefaultRounds } from "../lib/RC6.mjs"; + +/** + * RC6 Encrypt operation + */ +class RC6Encrypt extends Operation { + + /** + * RC6Encrypt constructor + */ + constructor() { + super(); + + this.name = "RC6 Encrypt"; + this.module = "Ciphers"; + this.description = "RC6 is a symmetric key block cipher derived from RC5. It was designed by Ron Rivest, Matt Robshaw, Ray Sidney, and Yiqun Lisa Yin to meet the requirements of the AES competition, and was one of the five finalists.
RC6 is parameterised as RC6-w/r/b where w is word size in bits (any multiple of 8 from 8-256), r is the number of rounds (1-255), and b is the key length in bytes. The standard AES submission uses w=32, r=20. Common word sizes: 8, 16, 32 (standard), 64, 128.
IV: The Initialisation Vector should be 4*w/8 bytes (e.g. 16 bytes for w=32). If not entered, it will default to null bytes.
Padding: In CBC and ECB mode, the PKCS#7 padding scheme is used."; + this.infoURL = "https://wikipedia.org/wiki/RC6"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Mode", + "type": "option", + "value": ["CBC", "CFB", "OFB", "CTR", "ECB"] + }, + { + "name": "Input", + "type": "option", + "value": ["Raw", "Hex"] + }, + { + "name": "Output", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Padding", + "type": "option", + "value": ["PKCS5", "NO", "ZERO", "RANDOM", "BIT"] + }, + { + "name": "Word Size", + "type": "number", + "value": 32, + "min": 8, + "max": 256, + "step": 8 + }, + { + "name": "Rounds", + "type": "number", + "value": 20, + "min": 1, + "max": 255 + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string, args[0].option), + iv = Utils.convertToByteArray(args[1].string, args[1].option), + [,, mode, inputType, outputType, padding, wordSize, rounds] = args; + + // Validate word size + if (!Number.isInteger(wordSize) || wordSize < 8 || wordSize > 256 || wordSize % 8 !== 0) + throw new OperationError(`Invalid word size: ${wordSize}. Must be a multiple of 8 between 8 and 256.`); + + const blockSize = getBlockSize(wordSize); + const defaultRounds = getDefaultRounds(wordSize); + + if (iv.length !== blockSize && iv.length !== 0 && mode !== "ECB") + throw new OperationError(`Invalid IV length: ${iv.length} bytes + +RC6-${wordSize} uses an IV length of ${blockSize} bytes (${blockSize * 8} bits). +Make sure you have specified the type correctly (e.g. Hex vs UTF8).`); + + if (!Number.isInteger(rounds) || rounds < 1 || rounds > 255) + throw new OperationError(`Invalid number of rounds: ${rounds} + +Rounds must be an integer between 1 and 255. Standard for w=${wordSize} is ${defaultRounds}.`); + + // Default IV to null bytes if empty (like AES) + const actualIv = iv.length === 0 ? new Array(blockSize).fill(0) : iv; + + input = Utils.convertToByteArray(input, inputType); + const output = encryptRC6(input, key, actualIv, mode, padding, rounds, wordSize); + return outputType === "Hex" ? toHex(output, "") : Utils.byteArrayToUtf8(output); + } + +} + +export default RC6Encrypt; diff --git a/src/core/operations/ROT13.mjs b/src/core/operations/ROT13.mjs index 1d059565..beec94a4 100644 --- a/src/core/operations/ROT13.mjs +++ b/src/core/operations/ROT13.mjs @@ -59,15 +59,16 @@ class ROT13 extends Operation { rot13Upperacse = args[1], rotNumbers = args[2]; let amount = args[3], - chr; + amountNumbers = args[3]; if (amount) { if (amount < 0) { amount = 26 - (Math.abs(amount) % 26); + amountNumbers = 10 - (Math.abs(amountNumbers) % 10); } for (let i = 0; i < input.length; i++) { - chr = input[i]; + let chr = input[i]; if (rot13Upperacse && chr >= 65 && chr <= 90) { // Upper case chr = (chr - 65 + amount) % 26; output[i] = chr + 65; @@ -75,7 +76,7 @@ class ROT13 extends Operation { chr = (chr - 97 + amount) % 26; output[i] = chr + 97; } else if (rotNumbers && chr >= 48 && chr <= 57) { // Numbers - chr = (chr - 48 + amount) % 10; + chr = (chr - 48 + amountNumbers) % 10; output[i] = chr + 48; } } diff --git a/src/core/operations/ROT13BruteForce.mjs b/src/core/operations/ROT13BruteForce.mjs index aefe2ab7..7468ee11 100644 --- a/src/core/operations/ROT13BruteForce.mjs +++ b/src/core/operations/ROT13BruteForce.mjs @@ -86,12 +86,12 @@ class ROT13BruteForce extends Operation { } const rotatedString = Utils.byteArrayToUtf8(rotated); if (rotatedString.toLowerCase().indexOf(cribLower) >= 0) { - const rotatedStringPrintable = Utils.printable(rotatedString, false); + const rotatedStringEscaped = Utils.escapeWhitespace(rotatedString); if (printAmount) { const amountStr = "Amount = " + (" " + amount).slice(-2) + ": "; - result.push(amountStr + rotatedStringPrintable); + result.push(amountStr + rotatedStringEscaped); } else { - result.push(rotatedStringPrintable); + result.push(rotatedStringEscaped); } } } diff --git a/src/core/operations/ROT47BruteForce.mjs b/src/core/operations/ROT47BruteForce.mjs index 5f346e00..fa1e90dc 100644 --- a/src/core/operations/ROT47BruteForce.mjs +++ b/src/core/operations/ROT47BruteForce.mjs @@ -66,12 +66,12 @@ class ROT47BruteForce extends Operation { } const rotatedString = Utils.byteArrayToUtf8(rotated); if (rotatedString.toLowerCase().indexOf(cribLower) >= 0) { - const rotatedStringPrintable = Utils.printable(rotatedString, false); + const rotatedStringEscaped = Utils.escapeWhitespace(rotatedString); if (printAmount) { const amountStr = "Amount = " + (" " + amount).slice(-2) + ": "; - result.push(amountStr + rotatedStringPrintable); + result.push(amountStr + rotatedStringEscaped); } else { - result.push(rotatedStringPrintable); + result.push(rotatedStringEscaped); } } } diff --git a/src/core/operations/RSASign.mjs b/src/core/operations/RSASign.mjs index 25160f53..5091549f 100644 --- a/src/core/operations/RSASign.mjs +++ b/src/core/operations/RSASign.mjs @@ -60,7 +60,7 @@ class RSASign extends Operation { const privateKey = forge.pki.decryptRsaPrivateKey(key, password); // Generate message hash const md = MD_ALGORITHMS[mdAlgo].create(); - md.update(input, "utf8"); + md.update(input, "raw"); // Sign message hash const sig = privateKey.sign(md); return sig; diff --git a/src/core/operations/RSAVerify.mjs b/src/core/operations/RSAVerify.mjs index 89b7d81f..8160438c 100644 --- a/src/core/operations/RSAVerify.mjs +++ b/src/core/operations/RSAVerify.mjs @@ -8,6 +8,7 @@ import Operation from "../Operation.mjs"; import OperationError from "../errors/OperationError.mjs"; import forge from "node-forge"; import { MD_ALGORITHMS } from "../lib/RSA.mjs"; +import Utils from "../Utils.mjs"; /** * RSA Verify operation @@ -37,6 +38,11 @@ class RSAVerify extends Operation { type: "text", value: "" }, + { + name: "Message format", + type: "option", + value: ["Raw", "Hex", "Base64"] + }, { name: "Message Digest Algorithm", type: "option", @@ -51,7 +57,7 @@ class RSAVerify extends Operation { * @returns {string} */ run(input, args) { - const [pemKey, message, mdAlgo] = args; + const [pemKey, message, format, mdAlgo] = args; if (pemKey.replace("-----BEGIN RSA PUBLIC KEY-----", "").length === 0) { throw new OperationError("Please enter a public key."); } @@ -60,7 +66,8 @@ class RSAVerify extends Operation { const pubKey = forge.pki.publicKeyFromPem(pemKey); // Generate message digest const md = MD_ALGORITHMS[mdAlgo].create(); - md.update(message, "utf8"); + const messageStr = Utils.convertToByteString(message, format); + md.update(messageStr, "raw"); // Compare signed message digest and generated message digest const result = pubKey.verify(md.digest().bytes(), input); return result ? "Verified OK" : "Verification Failure"; diff --git a/src/core/operations/Rabbit.mjs b/src/core/operations/Rabbit.mjs new file mode 100644 index 00000000..91ff24a3 --- /dev/null +++ b/src/core/operations/Rabbit.mjs @@ -0,0 +1,247 @@ +/** + * @author mikecat + * @copyright Crown Copyright 2022 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import Utils from "../Utils.mjs"; +import { toHexFast } from "../lib/Hex.mjs"; +import OperationError from "../errors/OperationError.mjs"; + +/** + * Rabbit operation + */ +class Rabbit extends Operation { + + /** + * Rabbit constructor + */ + constructor() { + super(); + + this.name = "Rabbit"; + this.module = "Ciphers"; + this.description = "Rabbit is a high-speed stream cipher introduced in 2003 and defined in RFC 4503.
The cipher uses a 128-bit key and an optional 64-bit initialization vector (IV).
big-endian: based on RFC4503 and RFC3447
little-endian: compatible with Crypto++"; + this.infoURL = "https://wikipedia.org/wiki/Rabbit_(cipher)"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Endianness", + "type": "option", + "value": ["Big", "Little"] + }, + { + "name": "Input", + "type": "option", + "value": ["Raw", "Hex"] + }, + { + "name": "Output", + "type": "option", + "value": ["Raw", "Hex"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string, args[0].option), + iv = Utils.convertToByteArray(args[1].string, args[1].option), + endianness = args[2], + inputType = args[3], + outputType = args[4]; + + const littleEndian = endianness === "Little"; + + if (key.length !== 16) { + throw new OperationError(`Invalid key length: ${key.length} bytes (expected: 16)`); + } + if (iv.length !== 0 && iv.length !== 8) { + throw new OperationError(`Invalid IV length: ${iv.length} bytes (expected: 0 or 8)`); + } + + // Inner State + const X = new Uint32Array(8), C = new Uint32Array(8); + let b = 0; + + // Counter System + const A = [ + 0x4d34d34d, 0xd34d34d3, 0x34d34d34, 0x4d34d34d, + 0xd34d34d3, 0x34d34d34, 0x4d34d34d, 0xd34d34d3 + ]; + const counterUpdate = function() { + for (let j = 0; j < 8; j++) { + const temp = C[j] + A[j] + b; + b = (temp / ((1 << 30) * 4)) >>> 0; + C[j] = temp; + } + }; + + // Next-State Function + const g = function(u, v) { + const uv = (u + v) >>> 0; + const upper = uv >>> 16, lower = uv & 0xffff; + const upperUpper = upper * upper; + const upperLower2 = 2 * upper * lower; + const lowerLower = lower * lower; + const mswTemp = upperUpper + ((upperLower2 / (1 << 16)) >>> 0); + const lswTemp = lowerLower + (upperLower2 & 0xffff) * (1 << 16); + const msw = mswTemp + ((lswTemp / ((1 << 30) * 4)) >>> 0); + const lsw = lswTemp >>> 0; + return lsw ^ msw; + }; + const leftRotate = function(value, width) { + return (value << width) | (value >>> (32 - width)); + }; + const nextStateHelper1 = function(v0, v1, v2) { + return v0 + leftRotate(v1, 16) + leftRotate(v2, 16); + }; + const nextStateHelper2 = function(v0, v1, v2) { + return v0 + leftRotate(v1, 8) + v2; + }; + const G = new Uint32Array(8); + const nextState = function() { + for (let j = 0; j < 8; j++) { + G[j] = g(X[j], C[j]); + } + X[0] = nextStateHelper1(G[0], G[7], G[6]); + X[1] = nextStateHelper2(G[1], G[0], G[7]); + X[2] = nextStateHelper1(G[2], G[1], G[0]); + X[3] = nextStateHelper2(G[3], G[2], G[1]); + X[4] = nextStateHelper1(G[4], G[3], G[2]); + X[5] = nextStateHelper2(G[5], G[4], G[3]); + X[6] = nextStateHelper1(G[6], G[5], G[4]); + X[7] = nextStateHelper2(G[7], G[6], G[5]); + }; + + // Key Setup Scheme + const K = new Uint16Array(8); + if (littleEndian) { + for (let i = 0; i < 8; i++) { + K[i] = (key[1 + 2 * i] << 8) | key[2 * i]; + } + } else { + for (let i = 0; i < 8; i++) { + K[i] = (key[14 - 2 * i] << 8) | key[15 - 2 * i]; + } + } + for (let j = 0; j < 8; j++) { + if (j % 2 === 0) { + X[j] = (K[(j + 1) % 8] << 16) | K[j]; + C[j] = (K[(j + 4) % 8] << 16) | K[(j + 5) % 8]; + } else { + X[j] = (K[(j + 5) % 8] << 16) | K[(j + 4) % 8]; + C[j] = (K[j] << 16) | K[(j + 1) % 8]; + } + } + for (let i = 0; i < 4; i++) { + counterUpdate(); + nextState(); + } + for (let j = 0; j < 8; j++) { + C[j] = C[j] ^ X[(j + 4) % 8]; + } + + // IV Setup Scheme + if (iv.length === 8) { + const getIVValue = function(a, b, c, d) { + if (littleEndian) { + return (iv[a] << 24) | (iv[b] << 16) | + (iv[c] << 8) | iv[d]; + } else { + return (iv[7 - a] << 24) | (iv[7 - b] << 16) | + (iv[7 - c] << 8) | iv[7 - d]; + } + }; + C[0] = C[0] ^ getIVValue(3, 2, 1, 0); + C[1] = C[1] ^ getIVValue(7, 6, 3, 2); + C[2] = C[2] ^ getIVValue(7, 6, 5, 4); + C[3] = C[3] ^ getIVValue(5, 4, 1, 0); + C[4] = C[4] ^ getIVValue(3, 2, 1, 0); + C[5] = C[5] ^ getIVValue(7, 6, 3, 2); + C[6] = C[6] ^ getIVValue(7, 6, 5, 4); + C[7] = C[7] ^ getIVValue(5, 4, 1, 0); + for (let i = 0; i < 4; i++) { + counterUpdate(); + nextState(); + } + } + + // Extraction Scheme + const S = new Uint8Array(16); + const extract = function() { + let pos = 0; + const addPart = function(value) { + S[pos++] = value >>> 8; + S[pos++] = value & 0xff; + }; + counterUpdate(); + nextState(); + addPart((X[6] >>> 16) ^ (X[1] & 0xffff)); + addPart((X[6] & 0xffff) ^ (X[3] >>> 16)); + addPart((X[4] >>> 16) ^ (X[7] & 0xffff)); + addPart((X[4] & 0xffff) ^ (X[1] >>> 16)); + addPart((X[2] >>> 16) ^ (X[5] & 0xffff)); + addPart((X[2] & 0xffff) ^ (X[7] >>> 16)); + addPart((X[0] >>> 16) ^ (X[3] & 0xffff)); + addPart((X[0] & 0xffff) ^ (X[5] >>> 16)); + if (littleEndian) { + for (let i = 0, j = S.length - 1; i < j;) { + const temp = S[i]; + S[i] = S[j]; + S[j] = temp; + i++; + j--; + } + } + }; + + const data = Utils.convertToByteString(input, inputType); + const result = new Uint8Array(data.length); + for (let i = 0; i <= data.length - 16; i += 16) { + extract(); + for (let j = 0; j < 16; j++) { + result[i + j] = data.charCodeAt(i + j) ^ S[j]; + } + } + if (data.length % 16 !== 0) { + const offset = data.length - data.length % 16; + const length = data.length - offset; + extract(); + if (littleEndian) { + for (let j = 0; j < length; j++) { + result[offset + j] = data.charCodeAt(offset + j) ^ S[j]; + } + } else { + for (let j = 0; j < length; j++) { + result[offset + j] = data.charCodeAt(offset + j) ^ S[16 - length + j]; + } + } + } + if (outputType === "Hex") { + return toHexFast(result); + } + return Utils.byteArrayToChars(result); + } + +} + +export default Rabbit; diff --git a/src/core/operations/RailFenceCipherDecode.mjs b/src/core/operations/RailFenceCipherDecode.mjs index be54ee12..39795f21 100644 --- a/src/core/operations/RailFenceCipherDecode.mjs +++ b/src/core/operations/RailFenceCipherDecode.mjs @@ -72,7 +72,7 @@ class RailFenceCipherDecode extends Operation { } } - return plaintext.join("").trim(); + return plaintext.join(""); } } diff --git a/src/core/operations/RailFenceCipherEncode.mjs b/src/core/operations/RailFenceCipherEncode.mjs index 03651f85..89eddde7 100644 --- a/src/core/operations/RailFenceCipherEncode.mjs +++ b/src/core/operations/RailFenceCipherEncode.mjs @@ -66,7 +66,7 @@ class RailFenceCipherEncode extends Operation { rows[rowIdx] += plaintext[pos]; } - return rows.join("").trim(); + return rows.join(""); } } diff --git a/src/core/operations/RandomizeColourPalette.mjs b/src/core/operations/RandomizeColourPalette.mjs index 9fe53a19..186023c2 100644 --- a/src/core/operations/RandomizeColourPalette.mjs +++ b/src/core/operations/RandomizeColourPalette.mjs @@ -10,14 +10,12 @@ import Utils from "../Utils.mjs"; import { isImage } from "../lib/FileType.mjs"; import { runHash } from "../lib/Hash.mjs"; import { toBase64 } from "../lib/Base64.mjs"; -import jimplib from "jimp/es/index.js"; -const jimp = jimplib.default ? jimplib.default : jimplib; +import { Jimp } from "jimp"; /** * Randomize Colour Palette operation */ class RandomizeColourPalette extends Operation { - /** * RandomizeColourPalette constructor */ @@ -26,7 +24,8 @@ class RandomizeColourPalette extends Operation { this.name = "Randomize Colour Palette"; this.module = "Image"; - this.description = "Randomizes each colour in an image's colour palette. This can often reveal text or symbols that were previously a very similar colour to their surroundings, a technique sometimes used in Steganography."; + this.description = + "Randomizes each colour in an image's colour palette. This can often reveal text or symbols that were previously a very similar colour to their surroundings, a technique sometimes used in Steganography."; this.infoURL = "https://wikipedia.org/wiki/Indexed_color"; this.inputType = "ArrayBuffer"; this.outputType = "ArrayBuffer"; @@ -35,8 +34,8 @@ class RandomizeColourPalette extends Operation { { name: "Seed", type: "string", - value: "" - } + value: "", + }, ]; } @@ -46,23 +45,24 @@ class RandomizeColourPalette extends Operation { * @returns {ArrayBuffer} */ async run(input, args) { - if (!isImage(input)) throw new OperationError("Please enter a valid image file."); + if (!isImage(input)) + throw new OperationError("Please enter a valid image file."); - const seed = args[0] || (Math.random().toString().substr(2)), - parsedImage = await jimp.read(input), + const seed = args[0] || Math.random().toString().substr(2), + parsedImage = await Jimp.read(input), width = parsedImage.bitmap.width, height = parsedImage.bitmap.height; let rgbString, rgbHash, rgbHex; - parsedImage.scan(0, 0, width, height, function(x, y, idx) { - rgbString = this.bitmap.data.slice(idx, idx+3).join("."); + parsedImage.scan(0, 0, width, height, function (x, y, idx) { + rgbString = this.bitmap.data.slice(idx, idx + 3).join("."); rgbHash = runHash("md5", Utils.strToArrayBuffer(seed + rgbString)); rgbHex = rgbHash.substr(0, 6) + "ff"; parsedImage.setPixelColor(parseInt(rgbHex, 16), x, y); }); - const imageBuffer = await parsedImage.getBufferAsync(jimp.AUTO); + const imageBuffer = await parsedImage.getBuffer(parsedImage.mime); return new Uint8Array(imageBuffer).buffer; } @@ -78,7 +78,6 @@ class RandomizeColourPalette extends Operation { return `
${rendered}
`;
}
+ /**
+ * Adds target="_blank" to links.
+ * @param {MarkdownIt} md
+ */
+ makeLinksOpenInNewTab(md) {
+ // Adapted from: https://github.com/markdown-it/markdown-it/blob/master/docs/architecture.md#renderer
+ // Remember old renderer, if overridden, or proxy to default renderer
+ const defaultRender = md.renderer.rules.link_open || function(tokens, idx, options, env, self) {
+ return self.renderToken(tokens, idx, options);
+ };
+
+ // eslint-disable-next-line camelcase
+ md.renderer.rules.link_open = function (tokens, idx, options, env, self) {
+ const token = tokens[idx];
+ if (token.attrIndex("target") >= 0) {
+ // Target attribute already set, do not replace.
+ return;
+ }
+ token.attrPush(["target", "_blank"]); // add new attribute
+
+ // pass token to default renderer.
+ return defaultRender(tokens, idx, options, env, self);
+ };
+ }
}
export default RenderMarkdown;
diff --git a/src/core/operations/ResizeImage.mjs b/src/core/operations/ResizeImage.mjs
index 2a6db965..bec07c4e 100644
--- a/src/core/operations/ResizeImage.mjs
+++ b/src/core/operations/ResizeImage.mjs
@@ -9,14 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import { Jimp, JimpMime, ResizeStrategy } from "jimp";
/**
* Resize Image operation
*/
class ResizeImage extends Operation {
-
/**
* ResizeImage constructor
*/
@@ -25,7 +23,8 @@ class ResizeImage extends Operation {
this.name = "Resize Image";
this.module = "Image";
- this.description = "Resizes an image to the specified width and height values.";
+ this.description =
+ "Resizes an image to the specified width and height values.";
this.infoURL = "https://wikipedia.org/wiki/Image_scaling";
this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer";
@@ -35,23 +34,23 @@ class ResizeImage extends Operation {
name: "Width",
type: "number",
value: 100,
- min: 1
+ min: 1,
},
{
name: "Height",
type: "number",
value: 100,
- min: 1
+ min: 1,
},
{
name: "Unit type",
type: "option",
- value: ["Pixels", "Percent"]
+ value: ["Pixels", "Percent"],
},
{
name: "Maintain aspect ratio",
type: "boolean",
- value: false
+ value: false,
},
{
name: "Resizing algorithm",
@@ -61,10 +60,10 @@ class ResizeImage extends Operation {
"Bilinear",
"Bicubic",
"Hermite",
- "Bezier"
+ "Bezier",
],
- defaultIndex: 1
- }
+ defaultIndex: 1,
+ },
];
}
@@ -81,11 +80,11 @@ class ResizeImage extends Operation {
resizeAlg = args[4];
const resizeMap = {
- "Nearest Neighbour": jimp.RESIZE_NEAREST_NEIGHBOR,
- "Bilinear": jimp.RESIZE_BILINEAR,
- "Bicubic": jimp.RESIZE_BICUBIC,
- "Hermite": jimp.RESIZE_HERMITE,
- "Bezier": jimp.RESIZE_BEZIER
+ "Nearest Neighbour": ResizeStrategy.NEAREST_NEIGHBOR,
+ Bilinear: ResizeStrategy.BILINEAR,
+ Bicubic: ResizeStrategy.BICUBIC,
+ Hermite: ResizeStrategy.HERMITE,
+ Bezier: ResizeStrategy.BEZIER,
};
if (!isImage(input)) {
@@ -94,29 +93,37 @@ class ResizeImage extends Operation {
let image;
try {
- image = await jimp.read(input);
+ image = await Jimp.read(input);
} catch (err) {
throw new OperationError(`Error loading image. (${err})`);
}
try {
if (unit === "Percent") {
- width = image.getWidth() * (width / 100);
- height = image.getHeight() * (height / 100);
+ width = image.width * (width / 100);
+ height = image.height * (height / 100);
}
if (isWorkerEnvironment())
self.sendStatusMessage("Resizing image...");
if (aspect) {
- image.scaleToFit(width, height, resizeMap[resizeAlg]);
+ image.scaleToFit({
+ w: width,
+ h: height,
+ mode: resizeMap[resizeAlg],
+ });
} else {
- image.resize(width, height, resizeMap[resizeAlg]);
+ image.resize({
+ w: width,
+ h: height,
+ mode: resizeMap[resizeAlg],
+ });
}
let imageBuffer;
- if (image.getMIME() === "image/gif") {
- imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+ if (image.mime === "image/gif") {
+ imageBuffer = await image.getBuffer(JimpMime.png);
} else {
- imageBuffer = await image.getBufferAsync(jimp.AUTO);
+ imageBuffer = await image.getBuffer(image.mime);
}
return imageBuffer.buffer;
} catch (err) {
@@ -140,7 +147,6 @@ class ResizeImage extends Operation {
return `SSDEEP hashes are now widely used for simple identification purposes (e.g. the 'Basic Properties' section in VirusTotal). Although 'better' fuzzy hashes are available, SSDEEP is still one of the primary choices because of its speed and being a de facto standard.
This operation is fundamentally the same as the CTPH operation, however their outputs differ in format."; - this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Ssdeep"; + this.infoURL = "https://forensics.wiki/ssdeep"; this.inputType = "string"; this.outputType = "string"; this.args = []; diff --git a/src/core/operations/Salsa20.mjs b/src/core/operations/Salsa20.mjs new file mode 100644 index 00000000..7a76cf26 --- /dev/null +++ b/src/core/operations/Salsa20.mjs @@ -0,0 +1,154 @@ +/** + * @author joostrijneveld [joost@joostrijneveld.nl] + * @copyright Crown Copyright 2024 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import OperationError from "../errors/OperationError.mjs"; +import Utils from "../Utils.mjs"; +import { toHex } from "../lib/Hex.mjs"; +import { salsa20Block } from "../lib/Salsa20.mjs"; + +/** + * Salsa20 operation + */ +class Salsa20 extends Operation { + + /** + * Salsa20 constructor + */ + constructor() { + super(); + + this.name = "Salsa20"; + this.module = "Ciphers"; + this.description = "Salsa20 is a stream cipher designed by Daniel J. Bernstein and submitted to the eSTREAM project; Salsa20/8 and Salsa20/12 are round-reduced variants. It is closely related to the ChaCha stream cipher.
Key: Salsa20 uses a key of 16 or 32 bytes (128 or 256 bits).
Nonce: Salsa20 uses a nonce of 8 bytes (64 bits).
Counter: Salsa uses a counter of 8 bytes (64 bits). The counter starts at zero at the start of the keystream, and is incremented at every 64 bytes."; + this.infoURL = "https://wikipedia.org/wiki/Salsa20"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Nonce", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64", "Integer"] + }, + { + "name": "Counter", + "type": "number", + "value": 0, + "min": 0 + }, + { + "name": "Rounds", + "type": "option", + "value": ["20", "12", "8"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Raw", "Hex"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string, args[0].option), + nonceType = args[1].option, + rounds = parseInt(args[3], 10), + inputType = args[4], + outputType = args[5]; + + if (key.length !== 16 && key.length !== 32) { + throw new OperationError(`Invalid key length: ${key.length} bytes. + +Salsa20 uses a key of 16 or 32 bytes (128 or 256 bits).`); + } + + let counter, nonce; + if (nonceType === "Integer") { + nonce = Utils.intToByteArray(parseInt(args[1].string, 10), 8, "little"); + } else { + nonce = Utils.convertToByteArray(args[1].string, args[1].option); + if (!(nonce.length === 8)) { + throw new OperationError(`Invalid nonce length: ${nonce.length} bytes. + +Salsa20 uses a nonce of 8 bytes (64 bits).`); + } + } + counter = Utils.intToByteArray(args[2], 8, "little"); + + const output = []; + input = Utils.convertToByteArray(input, inputType); + + let counterAsInt = Utils.byteArrayToInt(counter, "little"); + for (let i = 0; i < input.length; i += 64) { + counter = Utils.intToByteArray(counterAsInt, 8, "little"); + const stream = salsa20Block(key, nonce, counter, rounds); + for (let j = 0; j < 64 && i + j < input.length; j++) { + output.push(input[i + j] ^ stream[j]); + } + counterAsInt++; + } + + if (outputType === "Hex") { + return toHex(output); + } else { + return Utils.arrayBufferToStr(Uint8Array.from(output).buffer); + } + } + + /** + * Highlight Salsa20 + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlight(pos, args) { + const inputType = args[4], + outputType = args[5]; + if (inputType === "Raw" && outputType === "Raw") { + return pos; + } + } + + /** + * Highlight Salsa20 in reverse + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlightReverse(pos, args) { + const inputType = args[4], + outputType = args[5]; + if (inputType === "Raw" && outputType === "Raw") { + return pos; + } + } + +} + +export default Salsa20; diff --git a/src/core/operations/ScanForEmbeddedFiles.mjs b/src/core/operations/ScanForEmbeddedFiles.mjs index 411b4c1d..2e83fcb9 100644 --- a/src/core/operations/ScanForEmbeddedFiles.mjs +++ b/src/core/operations/ScanForEmbeddedFiles.mjs @@ -60,7 +60,7 @@ class ScanForEmbeddedFiles extends Operation { Extension: ${type.fileDetails.extension} MIME type: ${type.fileDetails.mime}\n`; - if (type.fileDetails.description && type.fileDetails.description.length) { + if (type?.fileDetails?.description?.length) { output += ` Description: ${type.fileDetails.description}\n`; } }); diff --git a/src/core/operations/SharpenImage.mjs b/src/core/operations/SharpenImage.mjs index 3882b7aa..1f5461f2 100644 --- a/src/core/operations/SharpenImage.mjs +++ b/src/core/operations/SharpenImage.mjs @@ -8,16 +8,13 @@ import Operation from "../Operation.mjs"; import OperationError from "../errors/OperationError.mjs"; import { isImage } from "../lib/FileType.mjs"; import { toBase64 } from "../lib/Base64.mjs"; -import { gaussianBlur } from "../lib/ImageManipulation.mjs"; import { isWorkerEnvironment } from "../Utils.mjs"; -import jimplib from "jimp/es/index.js"; -const jimp = jimplib.default ? jimplib.default : jimplib; +import { Jimp, JimpMime } from "jimp"; /** * Sharpen Image operation */ class SharpenImage extends Operation { - /** * SharpenImage constructor */ @@ -36,22 +33,22 @@ class SharpenImage extends Operation { name: "Radius", type: "number", value: 2, - min: 1 + min: 1, }, { name: "Amount", type: "number", value: 1, min: 0, - step: 0.1 + step: 0.1, }, { name: "Threshold", type: "number", value: 10, min: 0, - max: 100 - } + max: 100, + }, ]; } @@ -69,7 +66,7 @@ class SharpenImage extends Operation { let image; try { - image = await jimp.read(input); + image = await Jimp.read(input); } catch (err) { throw new OperationError(`Error loading image. (${err})`); } @@ -80,67 +77,102 @@ class SharpenImage extends Operation { const blurMask = image.clone(); if (isWorkerEnvironment()) - self.sendStatusMessage("Sharpening image... (Blurring cloned image)"); - const blurImage = gaussianBlur(image.clone(), radius); - + self.sendStatusMessage( + "Sharpening image... (Blurring cloned image)", + ); + const blurImage = image.clone().gaussian(radius); if (isWorkerEnvironment()) - self.sendStatusMessage("Sharpening image... (Creating unsharp mask)"); - blurMask.scan(0, 0, blurMask.bitmap.width, blurMask.bitmap.height, function(x, y, idx) { - const blurRed = blurImage.bitmap.data[idx]; - const blurGreen = blurImage.bitmap.data[idx + 1]; - const blurBlue = blurImage.bitmap.data[idx + 2]; + self.sendStatusMessage( + "Sharpening image... (Creating unsharp mask)", + ); + blurMask.scan( + 0, + 0, + blurMask.bitmap.width, + blurMask.bitmap.height, + function (x, y, idx) { + const blurRed = blurImage.bitmap.data[idx]; + const blurGreen = blurImage.bitmap.data[idx + 1]; + const blurBlue = blurImage.bitmap.data[idx + 2]; - const normalRed = this.bitmap.data[idx]; - const normalGreen = this.bitmap.data[idx + 1]; - const normalBlue = this.bitmap.data[idx + 2]; + const normalRed = this.bitmap.data[idx]; + const normalGreen = this.bitmap.data[idx + 1]; + const normalBlue = this.bitmap.data[idx + 2]; - // Subtract blurred pixel value from normal image - this.bitmap.data[idx] = (normalRed > blurRed) ? normalRed - blurRed : 0; - this.bitmap.data[idx + 1] = (normalGreen > blurGreen) ? normalGreen - blurGreen : 0; - this.bitmap.data[idx + 2] = (normalBlue > blurBlue) ? normalBlue - blurBlue : 0; - }); + // Subtract blurred pixel value from normal image + this.bitmap.data[idx] = + normalRed > blurRed ? normalRed - blurRed : 0; + this.bitmap.data[idx + 1] = + normalGreen > blurGreen ? normalGreen - blurGreen : 0; + this.bitmap.data[idx + 2] = + normalBlue > blurBlue ? normalBlue - blurBlue : 0; + }, + ); if (isWorkerEnvironment()) - self.sendStatusMessage("Sharpening image... (Merging with unsharp mask)"); - image.scan(0, 0, image.bitmap.width, image.bitmap.height, function(x, y, idx) { - let maskRed = blurMask.bitmap.data[idx]; - let maskGreen = blurMask.bitmap.data[idx + 1]; - let maskBlue = blurMask.bitmap.data[idx + 2]; + self.sendStatusMessage( + "Sharpening image... (Merging with unsharp mask)", + ); + image.scan( + 0, + 0, + image.bitmap.width, + image.bitmap.height, + function (x, y, idx) { + let maskRed = blurMask.bitmap.data[idx]; + let maskGreen = blurMask.bitmap.data[idx + 1]; + let maskBlue = blurMask.bitmap.data[idx + 2]; - const normalRed = this.bitmap.data[idx]; - const normalGreen = this.bitmap.data[idx + 1]; - const normalBlue = this.bitmap.data[idx + 2]; + const normalRed = this.bitmap.data[idx]; + const normalGreen = this.bitmap.data[idx + 1]; + const normalBlue = this.bitmap.data[idx + 2]; - // Calculate luminance - const maskLuminance = (0.2126 * maskRed + 0.7152 * maskGreen + 0.0722 * maskBlue); - const normalLuminance = (0.2126 * normalRed + 0.7152 * normalGreen + 0.0722 * normalBlue); + // Calculate luminance + const maskLuminance = + 0.2126 * maskRed + + 0.7152 * maskGreen + + 0.0722 * maskBlue; + const normalLuminance = + 0.2126 * normalRed + + 0.7152 * normalGreen + + 0.0722 * normalBlue; - let luminanceDiff; - if (maskLuminance > normalLuminance) { - luminanceDiff = maskLuminance - normalLuminance; - } else { - luminanceDiff = normalLuminance - maskLuminance; - } + let luminanceDiff; + if (maskLuminance > normalLuminance) { + luminanceDiff = maskLuminance - normalLuminance; + } else { + luminanceDiff = normalLuminance - maskLuminance; + } - // Scale mask colours by amount - maskRed = maskRed * amount; - maskGreen = maskGreen * amount; - maskBlue = maskBlue * amount; + // Scale mask colours by amount + maskRed = maskRed * amount; + maskGreen = maskGreen * amount; + maskBlue = maskBlue * amount; - // Only change pixel value if the difference is higher than threshold - if ((luminanceDiff / 255) * 100 >= threshold) { - this.bitmap.data[idx] = (normalRed + maskRed) <= 255 ? normalRed + maskRed : 255; - this.bitmap.data[idx + 1] = (normalGreen + maskGreen) <= 255 ? normalGreen + maskGreen : 255; - this.bitmap.data[idx + 2] = (normalBlue + maskBlue) <= 255 ? normalBlue + maskBlue : 255; - } - }); + // Only change pixel value if the difference is higher than threshold + if ((luminanceDiff / 255) * 100 >= threshold) { + this.bitmap.data[idx] = + normalRed + maskRed <= 255 ? + normalRed + maskRed : + 255; + this.bitmap.data[idx + 1] = + normalGreen + maskGreen <= 255 ? + normalGreen + maskGreen : + 255; + this.bitmap.data[idx + 2] = + normalBlue + maskBlue <= 255 ? + normalBlue + maskBlue : + 255; + } + }, + ); let imageBuffer; - if (image.getMIME() === "image/gif") { - imageBuffer = await image.getBufferAsync(jimp.MIME_PNG); + if (image.mime === "image/gif") { + imageBuffer = await image.getBuffer(JimpMime.png); } else { - imageBuffer = await image.getBufferAsync(jimp.AUTO); + imageBuffer = await image.getBuffer(image.mime); } return imageBuffer.buffer; } catch (err) { @@ -164,7 +196,6 @@ class SharpenImage extends Operation { return `
Co-ordinates will be converted to decimal degrees before being shown on the map.
Supported formats:
- Degrees Minutes Seconds (DMS)
- Degrees Decimal Minutes (DDM)
- Decimal Degrees (DD)
- Geohash
- Military Grid Reference System (MGRS)
- Ordnance Survey National Grid (OSNG)
- Universal Transverse Mercator (UTM)
This operation will not work offline."; - this.infoURL = "https://foundation.wikimedia.org/wiki/Maps_Terms_of_Use"; + this.infoURL = "https://osmfoundation.org/wiki/Terms_of_Use"; this.inputType = "string"; this.outputType = "string"; this.presentType = "html"; @@ -85,12 +86,19 @@ class ShowOnMap extends Operation { data = "0, 0"; } const zoomLevel = args[0]; - const tileUrl = "https://maps.wikimedia.org/osm-intl/{z}/{x}/{y}.png", - tileAttribution = "Wikimedia maps | © OpenStreetMap contributors", - leafletUrl = "https://unpkg.com/leaflet@1.5.0/dist/leaflet.js", - leafletCssUrl = "https://unpkg.com/leaflet@1.5.0/dist/leaflet.css"; + const tileUrl = "https://tile.openstreetmap.org/{z}/{x}/{y}.png", + tileAttribution = "© OpenStreetMap contributors", + leafletUrl = "https://unpkg.com/leaflet@1.9.4/dist/leaflet.js", + leafletCssUrl = "https://unpkg.com/leaflet@1.9.4/dist/leaflet.css"; return ` - + diff --git a/src/web/static/sitemap.mjs b/src/web/static/sitemap.mjs index b96047fc..4f8101d4 100644 --- a/src/web/static/sitemap.mjs +++ b/src/web/static/sitemap.mjs @@ -1,6 +1,5 @@ import sm from "sitemap"; -import OperationConfig from "../../core/config/OperationConfig.json" assert {type: "json"}; - +import OperationConfig from "../../core/config/OperationConfig.json" assert { type: "json" }; /** * Generates an XML sitemap for all CyberChef operations and a number of recipes. @@ -10,25 +9,25 @@ import OperationConfig from "../../core/config/OperationConfig.json" assert {typ * @license Apache-2.0 */ -const smStream = new sm.SitemapStream({ - hostname: "https://gchq.github.io/CyberChef", -}); +const baseUrl = "https://gchq.github.io/CyberChef/"; + +const smStream = new sm.SitemapStream({}); smStream.write({ - url: "/", + url: baseUrl, changefreq: "weekly", - priority: 1.0 + priority: 1.0, }); for (const op in OperationConfig) { smStream.write({ - url: `/?op=${encodeURIComponent(op)}`, + url: `${baseUrl}?op=${encodeURIComponent(op)}`, changeFreq: "yearly", - priority: 0.5 + priority: 0.5, }); } smStream.end(); sm.streamToPromise(smStream).then( - buffer => console.log(buffer.toString()) // eslint-disable-line no-console + (buffer) => console.log(buffer.toString()), // eslint-disable-line no-console ); diff --git a/src/web/static/structuredData.json b/src/web/static/structuredData.json index 08677281..e242f70e 100755 --- a/src/web/static/structuredData.json +++ b/src/web/static/structuredData.json @@ -1,23 +1,26 @@ [ { "@context": "http://schema.org", - "@type": "Organization", - "url": "https://gchq.github.io/CyberChef/", - "logo": "https://gchq.github.io/CyberChef/images/cyberchef-128x128.png", - "sameAs": [ - "https://github.com/gchq/CyberChef", - "https://www.npmjs.com/package/cyberchef" + "@graph": [ + { + "@type": "Organization", + "url": "https://gchq.github.io/CyberChef/", + "logo": "https://gchq.github.io/CyberChef/images/cyberchef-128x128.png", + "sameAs": [ + "https://github.com/gchq/CyberChef", + "https://www.npmjs.com/package/cyberchef" + ] + }, + { + "@type": "WebSite", + "url": "https://gchq.github.io/CyberChef/", + "name": "CyberChef", + "potentialAction": { + "@type": "SearchAction", + "target": "https://gchq.github.io/CyberChef/?op={operation_search_term}", + "query-input": "required name=operation_search_term" + } + } ] - }, - { - "@context": "http://schema.org", - "@type": "WebSite", - "url": "https://gchq.github.io/CyberChef/", - "name": "CyberChef", - "potentialAction": { - "@type": "SearchAction", - "target": "https://gchq.github.io/CyberChef/?op={operation_search_term}", - "query-input": "required name=operation_search_term" - } } -] +] \ No newline at end of file diff --git a/src/web/stylesheets/components/_list.css b/src/web/stylesheets/components/_list.css index 31e40837..b732b4c1 100755 --- a/src/web/stylesheets/components/_list.css +++ b/src/web/stylesheets/components/_list.css @@ -40,4 +40,13 @@ margin: 0 !important; border-radius: 0 !important; border: none; -} \ No newline at end of file +} + +.op-count { + float: right; + color: var(--subtext-font-colour); + font-weight: normal; + font-size: xx-small; + opacity: 0.5; + padding-left: .5em; +} diff --git a/src/web/stylesheets/components/_operation.css b/src/web/stylesheets/components/_operation.css index 7d45a9e2..a97fed70 100755 --- a/src/web/stylesheets/components/_operation.css +++ b/src/web/stylesheets/components/_operation.css @@ -27,17 +27,31 @@ } .ingredients { - display: grid; - grid-template-columns: auto auto auto; - grid-column-gap: 14px; + display: flex; + flex-flow: row wrap; + justify-content: flex-start; + column-gap: 14px; + row-gap: 0; } -.ingredients > div { - grid-column: 1 / span 3; +.ing-very-wide { + flex: 4 400px; } -.ingredients > div.inline { - grid-column: unset; +.ing-wide { + flex: 3 200px; +} + +.ing-medium { + flex: 2 120px; +} + +.ing-short { + flex: 1 80px; +} + +.ing-flexible { + flex-grow: 1; } .ingredients .form-group { @@ -55,6 +69,10 @@ select.arg { min-width: 100px; } +select.arg.form-control:not([size]):not([multiple]), select.custom-file-control:not([size]):not([multiple]) { + height: 100% !important; +} + textarea.arg { min-height: 74px; resize: vertical; @@ -64,6 +82,11 @@ div.toggle-string { flex: 1; } +input.toggle-string { + border-top-right-radius: 0 !important; + height: 100%; +} + .operation [class^='bmd-label'], .operation [class*=' bmd-label'] { top: 13px !important; @@ -160,7 +183,7 @@ div.toggle-string { } .input-group .form-control { - border-top-left-radius: 4px !important; + border-top-left-radius: 4px; } .input-group-append button { diff --git a/src/web/stylesheets/components/_pane.css b/src/web/stylesheets/components/_pane.css index f251fa27..54e67b3b 100755 --- a/src/web/stylesheets/components/_pane.css +++ b/src/web/stylesheets/components/_pane.css @@ -46,72 +46,6 @@ padding: 0; } -.io-card.card { - box-shadow: 0 4px 8px 0 rgba(0,0,0,0.2); - transition: 0.3s; - width: 400px; - height: 150px; - position: absolute; - top: 50%; - left: 50%; - transform: translate(-50%, -50%); - font-family: var(--primary-font-family); - color: var(--primary-font-colour); - line-height: 30px; - background-color: var(--primary-background-colour); - flex-direction: row; - padding-left: 10px; -} - -.io-card.card:hover { - box-shadow: 0 8px 16px 0 rgba(0,0,0,0.2); -} - -.io-card.card>img { - float: left; - width: auto; - height: auto; - max-width: 128px; - max-height: 128px; - margin-left: auto; - margin-top: auto; - margin-right: auto; - margin-bottom: auto; - padding: 0px; - -} - -.io-card.card .card-body .close { - position: absolute; - right: 10px; - top: 4px; -} - -.io-card.card .card-body { - float: left; - padding: 16px; - width: 250px; - white-space: nowrap; - overflow: hidden; - text-overflow: ellipsis; - user-select: text; -} - -.io-card.card .card-body>.btn { - margin-bottom: 5px; - margin-top: 5px; -} - -.io-card.card input[type=number] { - padding-right: 6px; - padding-left: 6px; - height: unset; -} - -.io-card.card .input-group { - padding-top: 5px; -} - #files .card-header .float-right a:hover { text-decoration: none; } diff --git a/src/web/stylesheets/index.css b/src/web/stylesheets/index.css index 960c7006..0565399f 100755 --- a/src/web/stylesheets/index.css +++ b/src/web/stylesheets/index.css @@ -36,4 +36,5 @@ @import "./layout/_structure.css"; /* Operations */ +@import "./operations/diff.css"; @import "./operations/json.css"; diff --git a/src/web/stylesheets/layout/_banner.css b/src/web/stylesheets/layout/_banner.css index 59856958..1ef5d766 100755 --- a/src/web/stylesheets/layout/_banner.css +++ b/src/web/stylesheets/layout/_banner.css @@ -26,6 +26,36 @@ color: var(--banner-url-colour); } +#options:focus { + background-color: #eef3ec; + border: solid black 2px; + border-radius: 4px; +} + +#support:focus { + background-color: #eef3ec; + border: solid black 2px; + border-radius: 4px; +} + +#notice:focus { + background-color: #eef3ec; + border: solid black 2px; + border-radius: 4px; +} + +#banner .col a:focus { + background-color: #eef3ec; + border: solid black 2px; + border-radius: 4px; +} + +#notice-wrapper #notice:focus { + background-color: #eef3ec; + border: solid black 2px; + border-radius: 4px; +} + #notice-wrapper { text-align: center; overflow: hidden; diff --git a/src/web/stylesheets/layout/_controls.css b/src/web/stylesheets/layout/_controls.css index c410704b..1edc41b5 100755 --- a/src/web/stylesheets/layout/_controls.css +++ b/src/web/stylesheets/layout/_controls.css @@ -6,27 +6,20 @@ * @license Apache-2.0 */ -:root { - --controls-height: 75px; -} - #controls { position: absolute; width: 100%; - height: var(--controls-height); bottom: 0; - padding: 0; - padding-top: 12px; + padding: 10px 0; border-top: 1px solid var(--primary-border-colour); background-color: var(--secondary-background-colour); } #controls-content { position: relative; - left: 50%; - top: 50%; - transform: translate(-50%, -50%); - transform-origin: center left; + display: flex; + flex-flow: row nowrap; + align-items: center; } #auto-bake-label { @@ -56,6 +49,7 @@ #controls .btn { border-radius: 30px; + margin: 0; } .output-maximised .hide-on-maximised-output { diff --git a/src/web/stylesheets/layout/_io.css b/src/web/stylesheets/layout/_io.css index 7811144a..0146bf27 100755 --- a/src/web/stylesheets/layout/_io.css +++ b/src/web/stylesheets/layout/_io.css @@ -7,41 +7,36 @@ */ #input-text, -#output-text, -#output-html { +#output-text { position: relative; width: 100%; height: 100%; margin: 0; - padding: 3px; - -moz-padding-start: 3px; - -moz-padding-end: 3px; - border: none; - border-width: 0px; - resize: none; background-color: transparent; - white-space: pre-wrap; - word-wrap: break-word; -} - -#output-wrapper{ - margin: 0; - padding: 0; -} - -#output-wrapper .textarea-wrapper { - width: 100%; - height: 100%; - box-sizing: border-box; overflow: hidden; - pointer-events: auto; + user-select: auto; } - +#output-text.html-output .cm-content, +#output-text.html-output .cm-line, #output-html { + display: block; + height: 100%; + user-select: auto; +} +#output-text.html-output .cm-line .cm-widgetBuffer, +#output-text.html-output .cm-line>br { display: none; - overflow-y: auto; - -moz-padding-start: 1px; /* Fixes bug in Firefox */ +} + +.cm-editor { + height: 100%; +} + +.cm-editor .cm-content { + font-family: var(--fixed-width-font-family); + font-size: var(--fixed-width-font-size); + color: var(--fixed-width-font-colour); } #input-tabs-wrapper #input-tabs, @@ -162,70 +157,25 @@ } #input-wrapper, -#output-wrapper, -#input-wrapper > * , -#output-wrapper > .textarea-wrapper > div, -#output-wrapper > .textarea-wrapper > textarea { +#output-wrapper { height: calc(100% - var(--title-height)); } #input-wrapper.show-tabs, -#input-wrapper.show-tabs > *, -#output-wrapper.show-tabs, -#output-wrapper.show-tabs > .textarea-wrapper > div, -#output-wrapper.show-tabs > .textarea-wrapper > textarea { +#output-wrapper.show-tabs { height: calc(100% - var(--tab-height) - var(--title-height)); } -#output-wrapper > .textarea-wrapper > #output-html { - height: 100%; -} - -#show-file-overlay { - height: 32px; -} - -.input-wrapper.textarea-wrapper { - width: 100%; - box-sizing: border-box; - overflow: hidden; - pointer-events: auto; -} - -.textarea-wrapper textarea, -.textarea-wrapper>div { - font-family: var(--fixed-width-font-family); - font-size: var(--fixed-width-font-size); - color: var(--fixed-width-font-colour); -} - -#input-highlighter, -#output-highlighter { - position: absolute; - left: 0; - bottom: 0; - width: 100%; - padding: 3px; - margin: 0; - overflow: hidden; - letter-spacing: normal; - white-space: pre-wrap; - word-wrap: break-word; - color: #fff; - background-color: transparent; - border: none; - pointer-events: none; -} - #output-loader { position: absolute; bottom: 0; left: 0; width: 100%; + height: 100%; margin: 0; - background-color: var(--primary-background-colour); - visibility: hidden; + background-color: var(--secondary-background-colour); opacity: 0; + visibility: hidden; display: flex; justify-content: center; align-items: center; @@ -254,31 +204,6 @@ transition: all 0.5s ease; } -#input-file, -#output-file { - position: absolute; - left: 0; - bottom: 0; - width: 100%; - display: none; -} - -.file-overlay { - position: absolute; - opacity: 0.8; - background-color: var(--title-background-colour); - width: 100%; - height: 100%; -} - -#show-file-overlay { - position: absolute; - right: 15px; - top: calc(var(--title-height) + 10px); - cursor: pointer; - display: none; -} - .io-info { margin-right: 18px; margin-top: 1px; @@ -292,10 +217,6 @@ align-items: center; } -#input-info { - line-height: 15px; -} - .dropping-file { border: 5px dashed var(--drop-file-border-colour) !important; } @@ -458,3 +379,214 @@ cursor: pointer; filter: brightness(98%); } + +/* Highlighting */ +.ͼ2.cm-focused .cm-selectionBackground { + background-color: var(--hl5); +} + +.ͼ2 .cm-selectionBackground { + background-color: var(--hl1); +} + +.ͼ1 .cm-selectionMatch { + background-color: var(--hl2); +} + +.ͼ1.cm-focused .cm-cursor.cm-cursor-primary { + border-color: var(--primary-font-colour); +} + +.ͼ1 .cm-cursor.cm-cursor-primary { + display: block; + border-color: var(--subtext-font-colour); +} + + +/* Status bar */ + +.cm-panel input::placeholder { + font-size: 12px !important; +} + +.ͼ2 .cm-panels, +.ͼ2 .cm-side-panels { + background-color: var(--secondary-background-colour); + border-color: var(--primary-border-colour); + color: var(--primary-font-colour); +} + +.cm-status-bar { + font-family: var(--fixed-width-font-family); + font-weight: normal; + font-size: 8pt; + margin: 0 5px; + display: flex; + flex-flow: row nowrap; + justify-content: space-between; + align-items: center; +} + +.cm-status-bar i { + font-size: 12pt; + vertical-align: middle; + margin-left: 8px; +} +.cm-status-bar>div>span:first-child i { + margin-left: 0; +} + +.cm-status-bar .disabled { + background-color: unset !important; + cursor: not-allowed; +} + +/* Dropup Button */ +.cm-status-bar-select-btn { + border: none; + cursor: pointer; +} + +/* The container
- needed to position the dropup content */
+.cm-status-bar-select {
+ position: relative;
+ display: inline-block;
+}
+
+/* Dropup content (Hidden by Default) */
+.cm-status-bar-select-content {
+ display: none;
+ position: absolute;
+ bottom: 20px;
+ right: 0;
+ background-color: #f1f1f1;
+ min-width: 200px;
+ box-shadow: 0px 4px 4px 0px rgba(0,0,0,0.2);
+ z-index: 1;
+}
+
+/* Links inside the dropup */
+.cm-status-bar-select-content a {
+ color: black;
+ padding: 2px 5px;
+ text-decoration: none;
+ display: block;
+}
+
+/* Change color of dropup links on hover */
+.cm-status-bar-select-content a:hover {
+ background-color: #ddd
+}
+
+/* Change the background color of the dropup button when the dropup content is shown */
+.cm-status-bar-select:hover .cm-status-bar-select-btn {
+ background-color: #f1f1f1;
+}
+
+/* The search field */
+.cm-status-bar-filter-input {
+ box-sizing: border-box;
+ font-size: 12px;
+ padding-left: 10px !important;
+ border: none;
+}
+
+.cm-status-bar-filter-search {
+ border-top: 1px solid #ddd;
+}
+
+/* Show the dropup menu */
+.cm-status-bar-select .show {
+ display: block;
+}
+
+.cm-status-bar-select-scroll {
+ overflow-y: auto;
+ max-height: 300px;
+}
+
+.chr-enc-value {
+ max-width: 150px;
+ display: inline-block;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ vertical-align: middle;
+}
+
+
+/* File details panel */
+
+.cm-file-details {
+ text-align: center;
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ overflow-y: auto;
+ padding-bottom: 21px;
+ height: 100%;
+}
+
+.file-details-toggle-shown,
+.file-details-toggle-hidden {
+ width: 8px;
+ height: 40px;
+ border: 1px solid var(--secondary-border-colour);
+ position: absolute;
+ top: calc(50% - 20px);
+ cursor: pointer;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ background-color: var(--secondary-border-colour);
+ color: var(--subtext-font-colour);
+ z-index: 1;
+}
+
+.file-details-toggle-shown {
+ left: 0;
+ border-left: none;
+ border-top-right-radius: 5px;
+ border-bottom-right-radius: 5px;
+}
+
+.file-details-toggle-hidden {
+ left: -8px;
+ border-right: none;
+ border-top-left-radius: 5px;
+ border-bottom-left-radius: 5px;
+}
+
+.file-details-toggle-shown:hover,
+.file-details-toggle-hidden:hover {
+ background-color: var(--primary-border-colour);
+ border-color: var(--primary-border-colour);
+ color: var(--primary-font-colour);
+}
+
+.file-details-heading {
+ font-weight: bold;
+ margin: 10px 0 10px 0;
+}
+
+.file-details-data {
+ text-align: left;
+ margin: 10px 2px;
+}
+
+.file-details-data td {
+ padding: 0 3px;
+ max-width: 130px;
+ min-width: 60px;
+ overflow: hidden;
+ vertical-align: top;
+ word-break: break-all;
+}
+
+.file-details-error {
+ color: #f00;
+}
+
+.file-details-thumbnail {
+ max-width: 180px;
+}
diff --git a/src/web/stylesheets/layout/_modals.css b/src/web/stylesheets/layout/_modals.css
index c1745eeb..e15bc3e9 100755
--- a/src/web/stylesheets/layout/_modals.css
+++ b/src/web/stylesheets/layout/_modals.css
@@ -78,6 +78,11 @@
border-left: 2px solid var(--primary-border-colour);
}
+p a:focus {
+ color: #0a6ebd;
+ text-decoration: underline;
+}
+
.checkbox label input[type=checkbox]+.checkbox-decorator .check,
.checkbox label input[type=checkbox]+.checkbox-decorator .check::before {
border-color: var(--input-border-colour);
@@ -99,12 +104,14 @@
.bmd-form-group.is-focused [class^='bmd-label'],
.bmd-form-group.is-focused [class*=' bmd-label'],
.bmd-form-group.is-focused label,
-.checkbox label:hover {
+.checkbox label:hover,
+.bmd-form-group.is-filled:focus-within .checkbox.option-item label {
color: var(--input-highlight-colour);
}
+
.bmd-form-group.option-item label+.form-control{
background-image:
linear-gradient(to top, var(--input-highlight-colour) 2px, rgba(0, 0, 0, 0) 2px),
linear-gradient(to top, var(--primary-border-colour) 1px, rgba(0, 0, 0, 0) 1px);
-}
\ No newline at end of file
+}
diff --git a/src/web/stylesheets/layout/_recipe.css b/src/web/stylesheets/layout/_recipe.css
index bd70d10f..339da074 100755
--- a/src/web/stylesheets/layout/_recipe.css
+++ b/src/web/stylesheets/layout/_recipe.css
@@ -7,7 +7,6 @@
*/
#rec-list {
- bottom: var(--controls-height);
overflow: auto;
}
diff --git a/src/web/stylesheets/operations/diff.css b/src/web/stylesheets/operations/diff.css
new file mode 100644
index 00000000..008cbbf5
--- /dev/null
+++ b/src/web/stylesheets/operations/diff.css
@@ -0,0 +1,8 @@
+del {
+ background-color: var(--hl3);
+}
+
+ins {
+ text-decoration: underline; /* shouldn't be needed, but Chromium doesn't copy to clipboard without it */
+ background-color: var(--hl5);
+}
diff --git a/src/web/stylesheets/operations/json.css b/src/web/stylesheets/operations/json.css
index 22c07128..27861c8f 100644
--- a/src/web/stylesheets/operations/json.css
+++ b/src/web/stylesheets/operations/json.css
@@ -44,7 +44,8 @@ ul.json-dict, ol.json-array {
display: contents;
}
.json-summary {
- display: contents;
+ display: inline;
+ list-style: none;
}
/* Display object and array brackets when closed */
diff --git a/src/web/stylesheets/themes/_classic.css b/src/web/stylesheets/themes/_classic.css
index 3b3bd555..971c1c57 100755
--- a/src/web/stylesheets/themes/_classic.css
+++ b/src/web/stylesheets/themes/_classic.css
@@ -110,11 +110,11 @@
/* Highlighter colours */
- --hl1: #fff000;
- --hl2: #95dfff;
- --hl3: #ffb6b6;
- --hl4: #fcf8e3;
- --hl5: #8de768;
+ --hl1: #ffee00aa;
+ --hl2: #95dfffaa;
+ --hl3: #ffb6b6aa;
+ --hl4: #fcf8e3aa;
+ --hl5: #8de768aa;
/* Scrollbar */
diff --git a/src/web/stylesheets/themes/_dark.css b/src/web/stylesheets/themes/_dark.css
index 10340ea8..4d2941f2 100755
--- a/src/web/stylesheets/themes/_dark.css
+++ b/src/web/stylesheets/themes/_dark.css
@@ -108,9 +108,9 @@
/* Highlighter colours */
--hl1: #264f78;
--hl2: #675351;
- --hl3: #ffb6b6;
+ --hl3: #c40000;
--hl4: #fcf8e3;
- --hl5: #8de768;
+ --hl5: #38811b;
/* Scrollbar */
diff --git a/src/web/stylesheets/themes/_solarizedDark.css b/src/web/stylesheets/themes/_solarizedDark.css
index 3b7d4338..5bb18d2e 100755
--- a/src/web/stylesheets/themes/_solarizedDark.css
+++ b/src/web/stylesheets/themes/_solarizedDark.css
@@ -125,9 +125,9 @@
/* Highlighter colours */
--hl1: var(--base01);
--hl2: var(--sol-blue);
- --hl3: var(--sol-magenta);
+ --hl3: var(--sol-green);
--hl4: var(--sol-yellow);
- --hl5: var(--sol-green);
+ --hl5: var(--sol-magenta);
/* Scrollbar */
diff --git a/src/web/stylesheets/themes/_solarizedLight.css b/src/web/stylesheets/themes/_solarizedLight.css
index 00b86091..f884c3e8 100755
--- a/src/web/stylesheets/themes/_solarizedLight.css
+++ b/src/web/stylesheets/themes/_solarizedLight.css
@@ -127,9 +127,9 @@
/* Highlighter colours */
--hl1: var(--base1);
--hl2: var(--sol-blue);
- --hl3: var(--sol-magenta);
+ --hl3: var(--sol-green);
--hl4: var(--sol-yellow);
- --hl5: var(--sol-green);
+ --hl5: var(--sol-magenta);
/* Scrollbar */
diff --git a/src/web/stylesheets/utils/_general.css b/src/web/stylesheets/utils/_general.css
index c40c4ccd..fd4a7d34 100755
--- a/src/web/stylesheets/utils/_general.css
+++ b/src/web/stylesheets/utils/_general.css
@@ -36,6 +36,10 @@ body {
line-height: 0;
}
+.hidden {
+ display: none;
+}
+
.blur {
color: transparent !important;
text-shadow: rgba(0, 0, 0, 0.95) 0 0 10px !important;
@@ -50,6 +54,11 @@ body {
padding-left: 2px;
}
+.modal-icon {
+ position: absolute;
+ right: 25px;
+}
+
.konami {
transform: rotate(180deg);
}
diff --git a/src/web/stylesheets/utils/_overrides.css b/src/web/stylesheets/utils/_overrides.css
index 7deabe7d..fec7d857 100755
--- a/src/web/stylesheets/utils/_overrides.css
+++ b/src/web/stylesheets/utils/_overrides.css
@@ -13,7 +13,7 @@
font-family: 'Material Icons';
font-style: normal;
font-weight: 400;
- src: url("../static/fonts/MaterialIcons-Regular.woff2") format('woff2');
+ src: url("../static/fonts/MaterialIcons-Regular.ttf") format('truetype');
}
.material-icons {
@@ -247,3 +247,18 @@ optgroup {
.colorpicker-color div {
height: 100px;
}
+
+
+/* Bootstrap form inside CodeMirror editor */
+
+.cm-panel > .bmd-form-group {
+ padding-top: 0;
+}
+
+
+/* CodeMirror */
+
+.ͼ2 .cm-specialChar,
+.cm-specialChar {
+ color: red;
+}
diff --git a/src/web/utils/copyOverride.mjs b/src/web/utils/copyOverride.mjs
new file mode 100644
index 00000000..51b2386b
--- /dev/null
+++ b/src/web/utils/copyOverride.mjs
@@ -0,0 +1,125 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ *
+ * In order to render whitespace characters as control character pictures in the output, even
+ * when they are the designated line separator, CyberChef sometimes chooses to represent them
+ * internally using the Unicode Private Use Area (https://en.wikipedia.org/wiki/Private_Use_Areas).
+ * See `Utils.escapeWhitespace()` for an example of this.
+ *
+ * The `renderSpecialChar()` function understands that it should display these characters as
+ * control pictures. When copying data from the Output, we need to replace these PUA characters
+ * with their original values, so we override the DOM "copy" event and modify the copied data
+ * if required. This handler is based closely on the built-in CodeMirror handler and defers to the
+ * built-in handler if PUA characters are not present in the copied data, in order to minimise the
+ * impact of breaking changes.
+ */
+
+import {EditorView} from "@codemirror/view";
+
+/**
+ * Copies the currently selected text from the state doc.
+ * Based on the built-in implementation with a few unrequired bits taken out:
+ * https://github.com/codemirror/view/blob/7d9c3e54396242d17b3164a0e244dcc234ee50ee/src/input.ts#L604
+ *
+ * @param {EditorState} state
+ * @returns {Object}
+ */
+function copiedRange(state) {
+ const content = [];
+ let linewise = false;
+ for (const range of state.selection.ranges) if (!range.empty) {
+ content.push(state.sliceDoc(range.from, range.to));
+ }
+ if (!content.length) {
+ // Nothing selected, do a line-wise copy
+ let upto = -1;
+ for (const {from} of state.selection.ranges) {
+ const line = state.doc.lineAt(from);
+ if (line.number > upto) {
+ content.push(line.text);
+ }
+ upto = line.number;
+ }
+ linewise = true;
+ }
+
+ return {text: content.join(state.lineBreak), linewise};
+}
+
+/**
+ * Regex to match characters in the Private Use Area of the Unicode table.
+ */
+const PUARegex = new RegExp("[\ue000-\uf8ff]");
+const PUARegexG = new RegExp("[\ue000-\uf8ff]", "g");
+/**
+ * Regex tto match Unicode Control Pictures.
+ */
+const CPRegex = new RegExp("[\u2400-\u243f]");
+const CPRegexG = new RegExp("[\u2400-\u243f]", "g");
+
+/**
+ * Overrides the DOM "copy" handler in the CodeMirror editor in order to return the original
+ * values of control characters that have been represented in the Unicode Private Use Area for
+ * visual purposes.
+ * Based on the built-in copy handler with some modifications:
+ * https://github.com/codemirror/view/blob/7d9c3e54396242d17b3164a0e244dcc234ee50ee/src/input.ts#L629
+ *
+ * This handler will defer to the built-in version if no PUA characters are present.
+ *
+ * @returns {Extension}
+ */
+export function copyOverride() {
+ return EditorView.domEventHandlers({
+ copy(event, view) {
+ const {text, linewise} = copiedRange(view.state);
+ if (!text && !linewise) return;
+
+ // If there are no PUA chars in the copied text, return false and allow the built-in
+ // copy handler to fire
+ if (!PUARegex.test(text)) return false;
+
+ // If PUA chars are detected, modify them back to their original values and copy that instead
+ const rawText = text.replace(PUARegexG, function(c) {
+ return String.fromCharCode(c.charCodeAt(0) - 0xe000);
+ });
+
+ event.preventDefault();
+ event.clipboardData.clearData();
+ event.clipboardData.setData("text/plain", rawText);
+
+ // Returning true prevents CodeMirror default handlers from firing
+ return true;
+ }
+ });
+}
+
+
+/**
+ * Handler for copy events in output-html decorations. If there are control pictures present,
+ * this handler will convert them back to their raw form before copying. If there are no
+ * control pictures present, it will do nothing and defer to the default browser handler.
+ *
+ * @param {ClipboardEvent} event
+ * @returns {boolean}
+ */
+export function htmlCopyOverride(event) {
+ const text = window.getSelection().toString();
+ if (!text) return;
+
+ // If there are no control picture chars in the copied text, return false and allow the built-in
+ // copy handler to fire
+ if (!CPRegex.test(text)) return false;
+
+ // If control picture chars are detected, modify them back to their original values and copy that instead
+ const rawText = text.replace(CPRegexG, function(c) {
+ return String.fromCharCode(c.charCodeAt(0) - 0x2400);
+ });
+
+ event.preventDefault();
+ event.clipboardData.clearData();
+ event.clipboardData.setData("text/plain", rawText);
+
+ return true;
+}
diff --git a/src/web/utils/editorUtils.mjs b/src/web/utils/editorUtils.mjs
new file mode 100644
index 00000000..fe1b6749
--- /dev/null
+++ b/src/web/utils/editorUtils.mjs
@@ -0,0 +1,136 @@
+/**
+ * CodeMirror utilities that are relevant to both the input and output
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import Utils from "../../core/Utils.mjs";
+
+// Descriptions for named control characters
+const Names = {
+ 0: "null",
+ 7: "bell",
+ 8: "backspace",
+ 10: "line feed",
+ 11: "vertical tab",
+ 13: "carriage return",
+ 27: "escape",
+ 8203: "zero width space",
+ 8204: "zero width non-joiner",
+ 8205: "zero width joiner",
+ 8206: "left-to-right mark",
+ 8207: "right-to-left mark",
+ 8232: "line separator",
+ 8237: "left-to-right override",
+ 8238: "right-to-left override",
+ 8294: "left-to-right isolate",
+ 8295: "right-to-left isolate",
+ 8297: "pop directional isolate",
+ 8233: "paragraph separator",
+ 65279: "zero width no-break space",
+ 65532: "object replacement"
+};
+
+// Regex for Special Characters to be replaced
+const UnicodeRegexpSupport = /x/.unicode != null ? "gu" : "g";
+const Specials = new RegExp("[\u0000-\u0008\u000a-\u001f\u007f-\u009f\u00ad\u061c\u200b\u200e\u200f\u2028\u2029\u202d\u202e\u2066\u2067\u2069\ufeff\ufff9-\ufffc\ue000-\uf8ff]", UnicodeRegexpSupport);
+
+
+/**
+ * Override for rendering special characters.
+ * Should mirror the toDOM function in
+ * https://github.com/codemirror/view/blob/main/src/special-chars.ts#L153
+ * But reverts the replacement of line feeds with newline control pictures.
+ *
+ * @param {number} code
+ * @param {string} desc
+ * @param {string} placeholder
+ * @returns {element}
+ */
+export function renderSpecialChar(code, desc, placeholder) {
+ const s = document.createElement("span");
+
+ // CodeMirror changes 0x0a to "NL" instead of "LF". We change it back along with its description.
+ if (code === 0x0a) {
+ placeholder = "\u240a";
+ desc = desc.replace("newline", "line feed");
+ }
+
+ // Render CyberChef escaped characters correctly - see Utils.escapeWhitespace
+ if (code >= 0xe000 && code <= 0xf8ff) {
+ code = code - 0xe000;
+ placeholder = String.fromCharCode(0x2400 + code);
+ desc = "Control character " + (Names[code] || "0x" + code.toString(16));
+ }
+
+ s.textContent = placeholder;
+ s.title = desc;
+ s.setAttribute("aria-label", desc);
+ s.className = "cm-specialChar";
+ return s;
+}
+
+
+/**
+ * Given a string, returns that string with any control characters replaced with HTML
+ * renderings of control pictures.
+ *
+ * @param {string} str
+ * @param {boolean} [preserveWs=false]
+ * @param {string} [lineBreak="\n"]
+ * @returns {html}
+ */
+export function escapeControlChars(str, preserveWs=false, lineBreak="\n") {
+ if (!preserveWs)
+ str = Utils.escapeWhitespace(str);
+
+ return str.replace(Specials, function(c) {
+ if (lineBreak.includes(c)) return c;
+ const code = c.charCodeAt(0);
+ const desc = "Control character " + (Names[code] || "0x" + code.toString(16));
+ const placeholder = code > 32 ? "\u2022" : String.fromCharCode(9216 + code);
+ const n = renderSpecialChar(code, desc, placeholder);
+ return n.outerHTML;
+ });
+}
+
+/**
+ * Convert and EOL sequence to its name
+ */
+export const eolSeqToCode = {
+ "\u000a": "LF",
+ "\u000b": "VT",
+ "\u000c": "FF",
+ "\u000d": "CR",
+ "\u000d\u000a": "CRLF",
+ "\u0085": "NEL",
+ "\u2028": "LS",
+ "\u2029": "PS"
+};
+
+/**
+ * Convert an EOL name to its sequence
+ */
+export const eolCodeToSeq = {
+ "LF": "\u000a",
+ "VT": "\u000b",
+ "FF": "\u000c",
+ "CR": "\u000d",
+ "CRLF": "\u000d\u000a",
+ "NEL": "\u0085",
+ "LS": "\u2028",
+ "PS": "\u2029"
+};
+
+export const eolCodeToName = {
+ "LF": "Line Feed",
+ "VT": "Vertical Tab",
+ "FF": "Form Feed",
+ "CR": "Carriage Return",
+ "CRLF": "Carriage Return + Line Feed",
+ "NEL": "Next Line",
+ "LS": "Line Separator",
+ "PS": "Paragraph Separator"
+};
diff --git a/src/web/utils/fileDetails.mjs b/src/web/utils/fileDetails.mjs
new file mode 100644
index 00000000..94f125f8
--- /dev/null
+++ b/src/web/utils/fileDetails.mjs
@@ -0,0 +1,147 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import {showSidePanel} from "./sidePanel.mjs";
+import Utils from "../../core/Utils.mjs";
+import {isImage, detectFileType} from "../../core/lib/FileType.mjs";
+
+/**
+ * A File Details extension for CodeMirror
+ */
+class FileDetailsPanel {
+
+ /**
+ * FileDetailsPanel constructor
+ * @param {Object} opts
+ */
+ constructor(opts) {
+ this.fileDetails = opts?.fileDetails;
+ this.progress = opts?.progress ?? 0;
+ this.status = opts?.status;
+ this.buffer = opts?.buffer;
+ this.renderPreview = opts?.renderPreview;
+ this.toggleHandler = opts?.toggleHandler;
+ this.hidden = opts?.hidden;
+ this.dom = this.buildDOM();
+ this.renderFileThumb();
+ }
+
+ /**
+ * Builds the file details DOM tree
+ * @returns {DOMNode}
+ */
+ buildDOM() {
+ const dom = document.createElement("div");
+
+ dom.className = "cm-file-details";
+ const fileThumb = require("../static/images/file-128x128.png");
+ dom.innerHTML = `
+
+
+ `;
+
+ dom.querySelector(".file-details-toggle-shown,.file-details-toggle-hidden")
+ .addEventListener("click", this.toggleHandler, false);
+
+ return dom;
+ }
+
+ /**
+ * Render the file thumbnail
+ */
+ renderFileThumb() {
+ if (!this.renderPreview) {
+ this.resetFileThumb();
+ return;
+ }
+ const fileThumb = this.dom.querySelector(".file-details-thumbnail");
+ const fileType = this.dom.querySelector(".file-details-type");
+ const fileBuffer = new Uint8Array(this.buffer);
+ const type = isImage(fileBuffer);
+
+ if (type && type !== "image/tiff" && fileBuffer.byteLength <= 512000) {
+ // Most browsers don't support displaying TIFFs, so ignore them
+ // Don't render images over 512,000 bytes
+ const blob = new Blob([fileBuffer], {type: type}),
+ url = URL.createObjectURL(blob);
+ fileThumb.src = url;
+ } else {
+ this.resetFileThumb();
+ }
+ fileType.textContent = type ? type : detectFileType(fileBuffer)[0]?.mime ?? "unknown";
+ }
+
+ /**
+ * Reset the file thumbnail to the default icon
+ */
+ resetFileThumb() {
+ const fileThumb = this.dom.querySelector(".file-details-thumbnail");
+ fileThumb.src = require("../static/images/file-128x128.png");
+ }
+
+}
+
+/**
+ * A panel constructor factory building a panel that displays file details
+ * @param {Object} opts
+ * @returns {Function}
+ */
+function makePanel(opts) {
+ const fdPanel = new FileDetailsPanel(opts);
+
+ return (view) => {
+ return {
+ dom: fdPanel.dom,
+ width: opts?.hidden ? 1 : 200,
+ update(update) {
+ },
+ mount() {
+ $("[data-toggle='tooltip']").tooltip();
+ }
+ };
+ };
+}
+
+/**
+ * A function that build the extension that enables the panel in an editor.
+ * @param {Object} opts
+ * @returns {Extension}
+ */
+export function fileDetailsPanel(opts) {
+ const panelMaker = makePanel(opts);
+ return showSidePanel.of(panelMaker);
+}
diff --git a/src/web/utils/htmlWidget.mjs b/src/web/utils/htmlWidget.mjs
new file mode 100644
index 00000000..642cd7e1
--- /dev/null
+++ b/src/web/utils/htmlWidget.mjs
@@ -0,0 +1,134 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import {WidgetType, Decoration, ViewPlugin} from "@codemirror/view";
+import {escapeControlChars} from "./editorUtils.mjs";
+import {htmlCopyOverride} from "./copyOverride.mjs";
+import Utils from "../../core/Utils.mjs";
+
+
+/**
+ * Adds an HTML widget to the Code Mirror editor
+ */
+class HTMLWidget extends WidgetType {
+
+ /**
+ * HTMLWidget consructor
+ */
+ constructor(html, view) {
+ super();
+ this.html = html;
+ this.view = view;
+ }
+
+ /**
+ * Builds the DOM node
+ * @returns {DOMNode}
+ */
+ toDOM() {
+ const wrap = document.createElement("span");
+ wrap.setAttribute("id", "output-html");
+ wrap.innerHTML = this.html;
+
+ // Find text nodes and replace unprintable chars with control codes
+ this.walkTextNodes(wrap);
+
+ // Add a handler for copy events to ensure the control codes are copied correctly
+ wrap.addEventListener("copy", htmlCopyOverride);
+ return wrap;
+ }
+
+ /**
+ * Walks all text nodes in a given element
+ * @param {DOMNode} el
+ */
+ walkTextNodes(el) {
+ for (const node of el.childNodes) {
+ switch (node.nodeType) {
+ case Node.TEXT_NODE:
+ this.replaceControlChars(node);
+ break;
+ default:
+ if (node.nodeName !== "SCRIPT" &&
+ node.nodeName !== "STYLE")
+ this.walkTextNodes(node);
+ break;
+ }
+ }
+ }
+
+ /**
+ * Renders control characters in text nodes
+ * @param {DOMNode} textNode
+ */
+ replaceControlChars(textNode) {
+ // .nodeValue unencodes HTML encoding such as < to "<"
+ // We must remember to escape any potential HTML in TextNodes as we do not
+ // want to render it.
+ const textValue = Utils.escapeHtml(textNode.nodeValue);
+ const val = escapeControlChars(textValue, true, this.view.state.lineBreak);
+ if (val.length !== textNode.nodeValue.length) {
+ const node = document.createElement("span");
+ node.innerHTML = val;
+ textNode.parentNode.replaceChild(node, textNode);
+ }
+ }
+
+}
+
+/**
+ * Decorator function to provide a set of widgets for the editor DOM
+ * @param {EditorView} view
+ * @param {string} html
+ * @returns {DecorationSet}
+ */
+function decorateHTML(view, html) {
+ const widgets = [];
+ if (html.length) {
+ const deco = Decoration.widget({
+ widget: new HTMLWidget(html, view),
+ side: 1
+ });
+ widgets.push(deco.range(0));
+ }
+ return Decoration.set(widgets);
+}
+
+
+/**
+ * An HTML Plugin builder
+ * @param {Object} htmlOutput
+ * @returns {ViewPlugin}
+ */
+export function htmlPlugin(htmlOutput) {
+ const plugin = ViewPlugin.fromClass(
+ class {
+ /**
+ * Plugin constructor
+ * @param {EditorView} view
+ */
+ constructor(view) {
+ this.htmlOutput = htmlOutput;
+ this.decorations = decorateHTML(view, this.htmlOutput.html);
+ }
+
+ /**
+ * Editor update listener
+ * @param {ViewUpdate} update
+ */
+ update(update) {
+ if (this.htmlOutput.changed) {
+ this.decorations = decorateHTML(update.view, this.htmlOutput.html);
+ this.htmlOutput.changed = false;
+ }
+ }
+ }, {
+ decorations: v => v.decorations
+ }
+ );
+
+ return plugin;
+}
diff --git a/src/web/utils/sidePanel.mjs b/src/web/utils/sidePanel.mjs
new file mode 100644
index 00000000..b54c08a0
--- /dev/null
+++ b/src/web/utils/sidePanel.mjs
@@ -0,0 +1,263 @@
+/**
+ * A modification of the CodeMirror Panel extension to enable panels to the
+ * left and right of the editor.
+ * Based on code here: https://github.com/codemirror/view/blob/main/src/panel.ts
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import {EditorView, ViewPlugin} from "@codemirror/view";
+import {Facet} from "@codemirror/state";
+
+const panelConfig = Facet.define({
+ combine(configs) {
+ let leftContainer, rightContainer;
+ for (const c of configs) {
+ leftContainer = leftContainer || c.leftContainer;
+ rightContainer = rightContainer || c.rightContainer;
+ }
+ return {leftContainer, rightContainer};
+ }
+});
+
+/**
+ * Configures the panel-managing extension.
+ * @param {PanelConfig} config
+ * @returns Extension
+ */
+export function panels(config) {
+ return config ? [panelConfig.of(config)] : [];
+}
+
+/**
+ * Get the active panel created by the given constructor, if any.
+ * This can be useful when you need access to your panels' DOM
+ * structure.
+ * @param {EditorView} view
+ * @param {PanelConstructor} panel
+ * @returns {Panel}
+ */
+export function getPanel(view, panel) {
+ const plugin = view.plugin(panelPlugin);
+ const index = plugin ? plugin.specs.indexOf(panel) : -1;
+ return index > -1 ? plugin.panels[index] : null;
+}
+
+const panelPlugin = ViewPlugin.fromClass(class {
+
+ /**
+ * @param {EditorView} view
+ */
+ constructor(view) {
+ this.input = view.state.facet(showSidePanel);
+ this.specs = this.input.filter(s => s);
+ this.panels = this.specs.map(spec => spec(view));
+ const conf = view.state.facet(panelConfig);
+ this.left = new PanelGroup(view, true, conf.leftContainer);
+ this.right = new PanelGroup(view, false, conf.rightContainer);
+ this.left.sync(this.panels.filter(p => p.left));
+ this.right.sync(this.panels.filter(p => !p.left));
+ for (const p of this.panels) {
+ p.dom.classList.add("cm-panel");
+ if (p.mount) p.mount();
+ }
+ }
+
+ /**
+ * @param {ViewUpdate} update
+ */
+ update(update) {
+ const conf = update.state.facet(panelConfig);
+ if (this.left.container !== conf.leftContainer) {
+ this.left.sync([]);
+ this.left = new PanelGroup(update.view, true, conf.leftContainer);
+ }
+ if (this.right.container !== conf.rightContainer) {
+ this.right.sync([]);
+ this.right = new PanelGroup(update.view, false, conf.rightContainer);
+ }
+ this.left.syncClasses();
+ this.right.syncClasses();
+ const input = update.state.facet(showSidePanel);
+ if (input !== this.input) {
+ const specs = input.filter(x => x);
+ const panels = [], left = [], right = [], mount = [];
+ for (const spec of specs) {
+ const known = this.specs.indexOf(spec);
+ let panel;
+ if (known < 0) {
+ panel = spec(update.view);
+ mount.push(panel);
+ } else {
+ panel = this.panels[known];
+ if (panel.update) panel.update(update);
+ }
+ panels.push(panel)
+ ;(panel.left ? left : right).push(panel);
+ }
+ this.specs = specs;
+ this.panels = panels;
+ this.left.sync(left);
+ this.right.sync(right);
+ for (const p of mount) {
+ p.dom.classList.add("cm-panel");
+ if (p.mount) p.mount();
+ }
+ } else {
+ for (const p of this.panels) if (p.update) p.update(update);
+ }
+ }
+
+ /**
+ * Destroy panel
+ */
+ destroy() {
+ this.left.sync([]);
+ this.right.sync([]);
+ }
+}, {
+ // provide: PluginField.scrollMargins.from(value => ({left: value.left.scrollMargin(), right: value.right.scrollMargin()}))
+});
+
+/**
+ * PanelGroup
+ */
+class PanelGroup {
+
+ /**
+ * @param {EditorView} view
+ * @param {boolean} left
+ * @param {HTMLElement} container
+ */
+ constructor(view, left, container) {
+ this.view = view;
+ this.left = left;
+ this.container = container;
+ this.dom = undefined;
+ this.classes = "";
+ this.panels = [];
+ this.syncClasses();
+ }
+
+ /**
+ * @param {Panel[]} panels
+ */
+ sync(panels) {
+ for (const p of this.panels) if (p.destroy && panels.indexOf(p) < 0) p.destroy();
+ this.panels = panels;
+ this.syncDOM();
+ }
+
+ /**
+ * Synchronise the DOM
+ */
+ syncDOM() {
+ if (this.panels.length === 0) {
+ if (this.dom) {
+ this.dom.remove();
+ this.dom = undefined;
+ this.setScrollerMargin(0);
+ }
+ return;
+ }
+
+ const parent = this.container || this.view.dom;
+ if (!this.dom) {
+ this.dom = document.createElement("div");
+ this.dom.className = this.left ? "cm-side-panels cm-panels-left" : "cm-side-panels cm-panels-right";
+ parent.insertBefore(this.dom, parent.firstChild);
+ }
+
+ let curDOM = this.dom.firstChild;
+ let bufferWidth = 0;
+ for (const panel of this.panels) {
+ bufferWidth += panel.width;
+ if (panel.dom.parentNode === this.dom) {
+ while (curDOM !== panel.dom) curDOM = rm(curDOM);
+ curDOM = curDOM.nextSibling;
+ } else {
+ this.dom.insertBefore(panel.dom, curDOM);
+ panel.dom.style.width = panel.width + "px";
+ this.dom.style.width = bufferWidth + "px";
+ }
+ }
+ while (curDOM) curDOM = rm(curDOM);
+
+ this.setScrollerMargin(bufferWidth);
+ }
+
+ /**
+ * Sets the margin of the cm-scroller element to make room for the panel
+ */
+ setScrollerMargin(width) {
+ const parent = this.container || this.view.dom;
+ const margin = this.left ? "marginLeft" : "marginRight";
+ parent.querySelector(".cm-scroller").style[margin] = width + "px";
+ }
+
+ /**
+ *
+ */
+ scrollMargin() {
+ return !this.dom || this.container ? 0 :
+ Math.max(0, this.left ?
+ this.dom.getBoundingClientRect().right - Math.max(0, this.view.scrollDOM.getBoundingClientRect().left) :
+ Math.min(innerHeight, this.view.scrollDOM.getBoundingClientRect().right) - this.dom.getBoundingClientRect().left);
+ }
+
+ /**
+ *
+ */
+ syncClasses() {
+ if (!this.container || this.classes === this.view.themeClasses) return;
+ for (const cls of this.classes.split(" ")) if (cls) this.container.classList.remove(cls);
+ for (const cls of (this.classes = this.view.themeClasses).split(" ")) if (cls) this.container.classList.add(cls);
+ }
+}
+
+/**
+ * @param {ChildNode} node
+ * @returns HTMLElement
+ */
+function rm(node) {
+ const next = node.nextSibling;
+ node.remove();
+ return next;
+}
+
+const baseTheme = EditorView.baseTheme({
+ ".cm-side-panels": {
+ boxSizing: "border-box",
+ position: "absolute",
+ height: "100%",
+ top: 0,
+ bottom: 0
+ },
+ "&light .cm-side-panels": {
+ backgroundColor: "#f5f5f5",
+ color: "black"
+ },
+ "&light .cm-panels-left": {
+ borderRight: "1px solid #ddd",
+ left: 0
+ },
+ "&light .cm-panels-right": {
+ borderLeft: "1px solid #ddd",
+ right: 0
+ },
+ "&dark .cm-side-panels": {
+ backgroundColor: "#333338",
+ color: "white"
+ }
+});
+
+/**
+ * Opening a panel is done by providing a constructor function for
+ * the panel through this facet. (The panel is closed again when its
+ * constructor is no longer provided.) Values of `null` are ignored.
+ */
+export const showSidePanel = Facet.define({
+ enables: [panelPlugin, baseTheme]
+});
diff --git a/src/web/utils/statusBar.mjs b/src/web/utils/statusBar.mjs
new file mode 100644
index 00000000..1adcd5be
--- /dev/null
+++ b/src/web/utils/statusBar.mjs
@@ -0,0 +1,515 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import {showPanel} from "@codemirror/view";
+import {CHR_ENC_SIMPLE_LOOKUP, CHR_ENC_SIMPLE_REVERSE_LOOKUP} from "../../core/lib/ChrEnc.mjs";
+import { eolCodeToName, eolSeqToCode } from "./editorUtils.mjs";
+
+/**
+ * A Status bar extension for CodeMirror
+ */
+class StatusBarPanel {
+
+ /**
+ * StatusBarPanel constructor
+ * @param {Object} opts
+ */
+ constructor(opts) {
+ this.label = opts.label;
+ this.timing = opts.timing;
+ this.tabNumGetter = opts.tabNumGetter;
+ this.eolHandler = opts.eolHandler;
+ this.chrEncHandler = opts.chrEncHandler;
+ this.chrEncGetter = opts.chrEncGetter;
+ this.getEncodingState = opts.getEncodingState;
+ this.getEOLState = opts.getEOLState;
+ this.htmlOutput = opts.htmlOutput;
+
+ this.eolVal = null;
+ this.chrEncVal = null;
+
+ this.dom = this.buildDOM();
+ }
+
+ /**
+ * Builds the status bar DOM tree
+ * @returns {DOMNode}
+ */
+ buildDOM() {
+ const dom = document.createElement("div");
+ const lhs = document.createElement("div");
+ const rhs = document.createElement("div");
+
+ dom.className = "cm-status-bar";
+ dom.setAttribute("data-help-title", `${this.label} status bar`);
+ dom.setAttribute("data-help", `This status bar provides information about data in the ${this.label}. Help topics are available for each of the components by activating help when hovering over them.`);
+ lhs.innerHTML = this.constructLHS();
+ rhs.innerHTML = this.constructRHS();
+
+ dom.appendChild(lhs);
+ dom.appendChild(rhs);
+
+ // Event listeners
+ dom.querySelectorAll(".cm-status-bar-select-btn").forEach(
+ el => el.addEventListener("click", this.showDropUp.bind(this), false)
+ );
+ dom.querySelector(".eol-select").addEventListener("click", this.eolSelectClick.bind(this), false);
+ dom.querySelector(".chr-enc-select").addEventListener("click", this.chrEncSelectClick.bind(this), false);
+ dom.querySelector(".cm-status-bar-filter-input").addEventListener("keyup", this.chrEncFilter.bind(this), false);
+
+ return dom;
+ }
+
+ /**
+ * Handler for dropup clicks
+ * Shows/Hides the dropup
+ * @param {Event} e
+ */
+ showDropUp(e) {
+ const el = e.target
+ .closest(".cm-status-bar-select")
+ .querySelector(".cm-status-bar-select-content");
+ const btn = e.target.closest(".cm-status-bar-select-btn");
+
+ if (btn.classList.contains("disabled")) return;
+
+ el.classList.add("show");
+
+ // Focus the filter input if present
+ const filter = el.querySelector(".cm-status-bar-filter-input");
+ if (filter) filter.focus();
+
+ // Set up a listener to close the menu if the user clicks outside of it
+ hideOnClickOutside(el, e);
+ }
+
+ /**
+ * Handler for EOL Select clicks
+ * Sets the line separator
+ * @param {Event} e
+ */
+ eolSelectClick(e) {
+ // preventDefault is required to stop the URL being modified and popState being triggered
+ e.preventDefault();
+
+ const eolCode = e.target.getAttribute("data-val");
+ if (!eolCode) return;
+
+ // Call relevant EOL change handler
+ this.eolHandler(e.target.getAttribute("data-val"), true);
+
+ hideElement(e.target.closest(".cm-status-bar-select-content"));
+ }
+
+ /**
+ * Handler for Chr Enc Select clicks
+ * Sets the character encoding
+ * @param {Event} e
+ */
+ chrEncSelectClick(e) {
+ // preventDefault is required to stop the URL being modified and popState being triggered
+ e.preventDefault();
+
+ const chrEncVal = parseInt(e.target.getAttribute("data-val"), 10);
+
+ if (isNaN(chrEncVal)) return;
+
+ this.chrEncHandler(chrEncVal, true);
+ this.updateCharEnc(chrEncVal);
+ hideElement(e.target.closest(".cm-status-bar-select-content"));
+ }
+
+ /**
+ * Handler for Chr Enc keyup events
+ * Filters the list of selectable character encodings
+ * @param {Event} e
+ */
+ chrEncFilter(e) {
+ const input = e.target;
+ const filter = input.value.toLowerCase();
+ const div = input.closest(".cm-status-bar-select-content");
+ const a = div.getElementsByTagName("a");
+ for (let i = 0; i < a.length; i++) {
+ const txtValue = a[i].textContent || a[i].innerText;
+ if (txtValue.toLowerCase().includes(filter)) {
+ a[i].style.display = "block";
+ } else {
+ a[i].style.display = "none";
+ }
+ }
+ }
+
+ /**
+ * Counts the stats of a document
+ * @param {EditorState} state
+ */
+ updateStats(state) {
+ const length = this.dom.querySelector(".stats-length-value"),
+ lines = this.dom.querySelector(".stats-lines-value");
+
+ let docLength = state.doc.length;
+ // CodeMirror always counts line breaks as one character.
+ // We want to show an accurate reading of how many bytes there are.
+ if (state.lineBreak.length !== 1) {
+ docLength += (state.lineBreak.length * state.doc.lines) - state.doc.lines - 1;
+ }
+ length.textContent = docLength;
+ lines.textContent = state.doc.lines;
+ }
+
+ /**
+ * Gets the current selection info
+ * @param {EditorState} state
+ * @param {boolean} selectionSet
+ */
+ updateSelection(state, selectionSet) {
+ const selLen = state?.selection?.main ?
+ state.selection.main.to - state.selection.main.from :
+ 0;
+
+ const selInfo = this.dom.querySelector(".sel-info"),
+ curOffsetInfo = this.dom.querySelector(".cur-offset-info");
+
+ if (!selectionSet) {
+ selInfo.style.display = "none";
+ curOffsetInfo.style.display = "none";
+ return;
+ }
+
+ // CodeMirror always counts line breaks as one character.
+ // We want to show an accurate reading of how many bytes there are.
+ let from = state.selection.main.from,
+ to = state.selection.main.to;
+ if (state.lineBreak.length !== 1) {
+ const fromLine = state.doc.lineAt(from).number;
+ const toLine = state.doc.lineAt(to).number;
+ from += (state.lineBreak.length * fromLine) - fromLine - 1;
+ to += (state.lineBreak.length * toLine) - toLine - 1;
+ }
+
+ if (selLen > 0) { // Range
+ const start = this.dom.querySelector(".sel-start-value"),
+ end = this.dom.querySelector(".sel-end-value"),
+ length = this.dom.querySelector(".sel-length-value");
+
+ selInfo.style.display = "inline-block";
+ curOffsetInfo.style.display = "none";
+ start.textContent = from;
+ end.textContent = to;
+ length.textContent = to - from;
+ } else { // Position
+ const offset = this.dom.querySelector(".cur-offset-value");
+
+ selInfo.style.display = "none";
+ curOffsetInfo.style.display = "inline-block";
+ offset.textContent = from;
+ }
+ }
+
+ /**
+ * Sets the current EOL separator in the status bar
+ * @param {EditorState} state
+ */
+ updateEOL(state) {
+ if (this.getEOLState() < 2 && state.lineBreak === this.eolVal) return;
+
+ const val = this.dom.querySelector(".eol-value");
+ const button = val.closest(".cm-status-bar-select-btn");
+ let eolCode = eolSeqToCode[state.lineBreak];
+ let eolName = eolCodeToName[eolCode];
+
+ switch (this.getEOLState()) {
+ case 1: // Detected
+ val.classList.add("font-italic");
+ eolCode += " (detected)";
+ eolName += " (detected)";
+ // Pulse
+ val.classList.add("pulse");
+ setTimeout(() => {
+ val.classList.remove("pulse");
+ }, 2000);
+ break;
+ case 0: // Unset
+ case 2: // Manually set
+ default:
+ val.classList.remove("font-italic");
+ break;
+ }
+
+ val.textContent = eolCode;
+ button.setAttribute("title", `End of line sequence:
${eolName}`); + button.setAttribute("data-original-title", `End of line sequence:
${eolName}`); + this.eolVal = state.lineBreak; + } + + + /** + * Sets the current character encoding of the document + */ + updateCharEnc() { + const chrEncVal = this.chrEncGetter(); + if (this.getEncodingState() < 2 && chrEncVal === this.chrEncVal) return; + + let name = CHR_ENC_SIMPLE_REVERSE_LOOKUP[chrEncVal] ? CHR_ENC_SIMPLE_REVERSE_LOOKUP[chrEncVal] : "Raw Bytes"; + + const val = this.dom.querySelector(".chr-enc-value"); + const button = val.closest(".cm-status-bar-select-btn"); + + switch (this.getEncodingState()) { + case 1: // Detected + val.classList.add("font-italic"); + name += " (detected)"; + // Pulse + val.classList.add("pulse"); + setTimeout(() => { + val.classList.remove("pulse"); + }, 2000); + break; + case 0: // Unset + case 2: // Manually set + default: + val.classList.remove("font-italic"); + break; + } + + val.textContent = name; + button.setAttribute("title", `${this.label} character encoding:
${name}`); + button.setAttribute("data-original-title", `${this.label} character encoding:
${name}`); + this.chrEncVal = chrEncVal; + } + + /** + * Sets the latest timing info + */ + updateTiming() { + if (!this.timing) return; + + const bakingTime = this.dom.querySelector(".baking-time-value"); + const bakingTimeInfo = this.dom.querySelector(".baking-time-info"); + + if (this.label === "Output" && this.timing) { + bakingTimeInfo.style.display = "inline-block"; + bakingTime.textContent = this.timing.duration(this.tabNumGetter()); + + const info = this.timing.printStages(this.tabNumGetter()).replace(/\n/g, "
"); + bakingTimeInfo.setAttribute("data-original-title", info); + } else { + bakingTimeInfo.style.display = "none"; + } + } + + /** + * Updates the sizing of elements that need to fit correctly + * @param {EditorView} view + */ + updateSizing(view) { + const viewHeight = view.contentDOM.parentNode.clientHeight; + this.dom.querySelectorAll(".cm-status-bar-select-scroll").forEach( + el => { + el.style.maxHeight = (viewHeight - 50) + "px"; + } + ); + } + + /** + * Checks whether there is HTML output requiring some widgets to be disabled + */ + monitorHTMLOutput() { + if (!this.htmlOutput?.changed) return; + + if (this.htmlOutput?.html === "") { + // Enable all controls + this.dom.querySelectorAll(".disabled").forEach(el => { + el.classList.remove("disabled"); + }); + } else { + // Disable chrenc, length, selection etc. + this.dom.querySelectorAll(".cm-status-bar-select-btn").forEach(el => { + el.classList.add("disabled"); + }); + + this.dom.querySelector(".stats-length-value").parentNode.classList.add("disabled"); + this.dom.querySelector(".stats-lines-value").parentNode.classList.add("disabled"); + this.dom.querySelector(".sel-info").classList.add("disabled"); + this.dom.querySelector(".cur-offset-info").classList.add("disabled"); + } + } + + /** + * Builds the Left-hand-side widgets + * @returns {string} + */ + constructLHS() { + return ` + + abc + + + + sort + + + + + highlight_alt + \u279E + ( selected) + + + location_on + + `; + } + + /** + * Builds the Right-hand-side widgets + * Event listener set up in Manager + * + * @returns {string} + */ + constructRHS() { + const chrEncOptions = Object.keys(CHR_ENC_SIMPLE_LOOKUP).map(name => + `${name}` + ).join(""); + + let chrEncHelpText = "", + eolHelpText = ""; + if (this.label === "Input") { + chrEncHelpText = "The input character encoding defines how the input text is encoded into bytes which are then processed by the Recipe.
The 'Raw bytes' option attempts to treat the input as individual bytes in the range 0-255. If it detects any characters with Unicode values above 255, it will treat the entire input as UTF-8. 'Raw bytes' is usually the best option if you are inputting binary data, such as a file."; + eolHelpText = "The End of Line Sequence defines which bytes are considered EOL terminators. Pressing the return key will enter this value into the input and create a new line.
Changing the EOL sequence will not modify any existing data in the input but may change how previously entered line breaks are displayed. Lines added while a different EOL terminator was set may not now result in a new line, but may be displayed as control characters instead."; + } else { + chrEncHelpText = "The output character encoding defines how the output bytes are decoded into text which can be displayed to you.
The 'Raw bytes' option treats the output data as individual bytes in the range 0-255."; + eolHelpText = "The End of Line Sequence defines which bytes are considered EOL terminators.
Changing this value will not modify the value of the output, but may change how certain bytes are displayed and whether they result in a new line being created."; + } + + return ` + + + + + `; + } + +} + +const elementsWithListeners = {}; + +/** + * Hides the provided element when a click is made outside of it + * @param {Element} element + * @param {Event} instantiatingEvent + */ +function hideOnClickOutside(element, instantiatingEvent) { + /** + * Handler for document click events + * Closes element if click is outside it. + * @param {Event} event + */ + const outsideClickListener = event => { + // Don't trigger if we're clicking inside the element, or if the element + // is not visible, or if this is the same click event that opened it. + if (!element.contains(event.target) && + event.timeStamp !== instantiatingEvent.timeStamp) { + hideElement(element); + } + }; + + if (!Object.prototype.hasOwnProperty.call(elementsWithListeners, element)) { + elementsWithListeners[element] = outsideClickListener; + document.addEventListener("click", elementsWithListeners[element], false); + } +} + +/** + * Hides the specified element and removes the click listener for it + * @param {Element} element + */ +function hideElement(element) { + element.classList.remove("show"); + document.removeEventListener("click", elementsWithListeners[element], false); + delete elementsWithListeners[element]; +} + + +/** + * A panel constructor factory building a panel that re-counts the stats every time the document changes. + * @param {Object} opts + * @returns {Function}
+ */
+function makePanel(opts) {
+ const sbPanel = new StatusBarPanel(opts);
+
+ return (view) => {
+ sbPanel.updateEOL(view.state);
+ sbPanel.updateCharEnc();
+ sbPanel.updateTiming();
+ sbPanel.updateStats(view.state);
+ sbPanel.updateSelection(view.state, false);
+ sbPanel.monitorHTMLOutput();
+
+ return {
+ "dom": sbPanel.dom,
+ update(update) {
+ sbPanel.updateEOL(update.state);
+ sbPanel.updateCharEnc();
+ sbPanel.updateSelection(update.state, update.selectionSet);
+ sbPanel.updateTiming();
+ sbPanel.monitorHTMLOutput();
+ if (update.geometryChanged) {
+ sbPanel.updateSizing(update.view);
+ }
+ if (update.docChanged) {
+ sbPanel.updateStats(update.state);
+ }
+ }
+ };
+ };
+}
+
+/**
+ * A function that build the extension that enables the panel in an editor.
+ * @param {Object} opts
+ * @returns {Extension}
+ */
+export function statusBar(opts) {
+ const panelMaker = makePanel(opts);
+ return showPanel.of(panelMaker);
+}
diff --git a/src/web/waiters/BackgroundWorkerWaiter.mjs b/src/web/waiters/BackgroundWorkerWaiter.mjs
index f06f9bce..409c2bbb 100644
--- a/src/web/waiters/BackgroundWorkerWaiter.mjs
+++ b/src/web/waiters/BackgroundWorkerWaiter.mjs
@@ -35,6 +35,14 @@ class BackgroundWorkerWaiter {
log.debug("Registering new background ChefWorker");
this.chefWorker = new ChefWorker();
this.chefWorker.addEventListener("message", this.handleChefMessage.bind(this));
+ this.chefWorker.postMessage({
+ action: "setLogPrefix",
+ data: "BGChefWorker"
+ });
+ this.chefWorker.postMessage({
+ action: "setLogLevel",
+ data: log.getLevel()
+ });
let docURL = document.location.href.split(/[#?]/)[0];
const index = docURL.lastIndexOf("/");
@@ -52,7 +60,7 @@ class BackgroundWorkerWaiter {
*/
handleChefMessage(e) {
const r = e.data;
- log.debug("Receiving '" + r.action + "' from ChefWorker in the background");
+ log.debug(`Receiving '${r.action}' from BGChefWorker`);
switch (r.action) {
case "bakeComplete":
@@ -152,6 +160,18 @@ class BackgroundWorkerWaiter {
this.manager.output.backgroundMagicResult(response.dish.value);
}
+
+ /**
+ * Sets the console log level in the workers.
+ */
+ setLogLevel() {
+ if (!this.chefWorker) return;
+ this.chefWorker.postMessage({
+ action: "setLogLevel",
+ data: log.getLevel()
+ });
+ }
+
}
diff --git a/src/web/waiters/BindingsWaiter.mjs b/src/web/waiters/BindingsWaiter.mjs
index 79c2903b..3766b8d5 100755
--- a/src/web/waiters/BindingsWaiter.mjs
+++ b/src/web/waiters/BindingsWaiter.mjs
@@ -40,11 +40,11 @@ class BindingsWaiter {
break;
case "KeyI": // Focus input
e.preventDefault();
- document.getElementById("input-text").focus();
+ this.manager.input.inputEditorView.focus();
break;
case "KeyO": // Focus output
e.preventDefault();
- document.getElementById("output-text").focus();
+ this.manager.output.outputEditorView.focus();
break;
case "Period": // Focus next operation
e.preventDefault();
@@ -126,7 +126,7 @@ class BindingsWaiter {
break;
case "KeyW": // Close tab
e.preventDefault();
- this.manager.input.removeInput(this.manager.tabs.getActiveInputTab());
+ this.manager.input.removeInput(this.manager.tabs.getActiveTab("input"));
break;
case "ArrowLeft": // Go to previous tab
e.preventDefault();
@@ -148,6 +148,13 @@ class BindingsWaiter {
}
break;
}
+ } else {
+ switch (e.code) {
+ case "F1":
+ e.preventDefault();
+ this.contextualHelp();
+ break;
+ }
}
}
@@ -164,9 +171,14 @@ class BindingsWaiter {
}
document.getElementById("keybList").innerHTML = `
- Command
- Shortcut (Win/Linux)
- Shortcut (Mac)
+ Command
+ Shortcut (Win/Linux)
+ Shortcut (Mac)
+
+
+ Activate contextual help
+ F1
+ F1
Place cursor in search field
@@ -255,6 +267,42 @@ class BindingsWaiter {
`;
}
+ /**
+ * Shows contextual help message based on where the mouse pointer is
+ */
+ contextualHelp() {
+ const hoveredHelpEls = document.querySelectorAll(":hover[data-help],:hover[data-help-proxy]");
+ if (!hoveredHelpEls.length) return;
+
+ let helpEl = hoveredHelpEls[hoveredHelpEls.length - 1];
+ const helpElSelector = helpEl.getAttribute("data-help-proxy");
+ if (helpElSelector) {
+ // A hovered element is directing us to another element for its help text
+ helpEl = document.querySelector(helpElSelector);
+ }
+ this.displayHelp(helpEl);
+ }
+
+ /**
+ * Displays the help pane populated with help text associated with the given element
+ *
+ * @param {Element} el
+ */
+ displayHelp(el) {
+ const helpText = el.getAttribute("data-help");
+ let helpTitle = el.getAttribute("data-help-title");
+
+ if (helpTitle)
+ helpTitle = "Help topic: " + helpTitle;
+ else
+ helpTitle = "Help topic";
+
+ document.querySelector("#help-modal .modal-body").innerHTML = helpText;
+ document.querySelector("#help-modal #help-title").innerHTML = helpTitle;
+
+ $("#help-modal").modal();
+ }
+
}
export default BindingsWaiter;
diff --git a/src/web/waiters/ControlsWaiter.mjs b/src/web/waiters/ControlsWaiter.mjs
index 5a9533f5..7f2bb683 100755
--- a/src/web/waiters/ControlsWaiter.mjs
+++ b/src/web/waiters/ControlsWaiter.mjs
@@ -5,6 +5,7 @@
*/
import Utils from "../../core/Utils.mjs";
+import { eolSeqToCode } from "../utils/editorUtils.mjs";
/**
@@ -35,6 +36,11 @@ class ControlsWaiter {
boundary: "viewport",
trigger: "hover"
});
+
+ // Set number of operations in various places in the DOM
+ document.querySelectorAll(".num-ops").forEach(el => {
+ el.innerHTML = Object.keys(this.app.operations).length;
+ });
}
@@ -51,6 +57,18 @@ class ControlsWaiter {
}
}
+ /**
+ * Checks or unchecks the Auto Bake checkbox with "Enter"
+ * @param {Event} ev
+ */
+ autoBakeKeyboardHandler(ev) {
+ const checkBox = document.getElementById("auto-bake");
+ ev.preventDefault();
+ if (ev.key === "Enter" || ev.key === " ") {
+ checkBox.checked = !checkBox.checked;
+ }
+ }
+
/**
* Handler to trigger baking.
@@ -138,9 +156,18 @@ class ControlsWaiter {
}
}
+ const inputChrEnc = this.manager.input.getChrEnc();
+ const outputChrEnc = this.manager.output.getChrEnc();
+ const inputEOL = eolSeqToCode[this.manager.input.getEOLSeq()];
+ const outputEOL = eolSeqToCode[this.manager.output.getEOLSeq()];
+
const params = [
includeRecipe ? ["recipe", recipeStr] : undefined,
- includeInput ? ["input", Utils.escapeHtml(input)] : undefined,
+ includeInput && input.length ? ["input", Utils.escapeHtml(input)] : undefined,
+ inputChrEnc !== 0 ? ["ienc", inputChrEnc] : undefined,
+ outputChrEnc !== 0 ? ["oenc", outputChrEnc] : undefined,
+ inputEOL !== "LF" ? ["ieol", inputEOL] : undefined,
+ outputEOL !== "LF" ? ["oeol", outputEOL] : undefined
];
const hash = params
@@ -335,6 +362,36 @@ class ControlsWaiter {
}
+ /**
+ * Hides the arguments for all the operations in the current recipe.
+ */
+ hideRecipeArgsClick() {
+ const icon = document.getElementById("hide-icon");
+
+ if (icon.getAttribute("hide-args") === "false") {
+ icon.setAttribute("hide-args", "true");
+ icon.setAttribute("data-original-title", "Show arguments");
+ icon.children[0].innerText = "keyboard_arrow_down";
+ Array.from(document.getElementsByClassName("hide-args-icon")).forEach(function(item) {
+ item.setAttribute("hide-args", "true");
+ item.innerText = "keyboard_arrow_down";
+ item.classList.add("hide-args-selected");
+ item.parentNode.previousElementSibling.style.display = "none";
+ });
+ } else {
+ icon.setAttribute("hide-args", "false");
+ icon.setAttribute("data-original-title", "Hide arguments");
+ icon.children[0].innerText = "keyboard_arrow_up";
+ Array.from(document.getElementsByClassName("hide-args-icon")).forEach(function(item) {
+ item.setAttribute("hide-args", "false");
+ item.innerText = "keyboard_arrow_up";
+ item.classList.remove("hide-args-selected");
+ item.parentNode.previousElementSibling.style.display = "grid";
+ });
+ }
+ }
+
+
/**
* Populates the bug report information box with useful technical info.
*
@@ -342,6 +399,18 @@ class ControlsWaiter {
*/
supportButtonClick(e) {
e.preventDefault();
+ const faqs = document.getElementById("faqs");
+ const faqsAElement = faqs.getElementsByTagName("a");
+ for (let i = 0; i < faqsAElement.length; i++) {
+ faqsAElement[i].setAttribute("tabindex", "0");
+ faqsAElement[i].addEventListener("keydown", this.navigateFAQList, false);
+ }
+
+ const tabs = document.querySelectorAll('[role="tab"]');
+
+ for (let i = 0; i < tabs.length; i++) {
+ tabs[i].addEventListener("keydown", this.changeTabs, false);
+ }
const reportBugInfo = document.getElementById("report-bug-info");
const saveLink = this.generateStateUrl(true, true, null, null, "https://gchq.github.io/CyberChef/");
@@ -358,6 +427,64 @@ ${navigator.userAgent}
}
+ /**
+ * @param {Event} ev
+ */
+ changeTabs(ev) {
+ const tab = ev.target;
+ ev.preventDefault();
+ ev.stopPropagation();
+
+ if (ev.key === "ArrowRight") {
+ const nextTab = tab.parentElement;
+ if (nextTab.nextElementSibling === null) {
+ tab.parentElement.parentElement.firstElementChild.firstElementChild.focus();
+ } else {
+ nextTab.nextElementSibling.firstElementChild.focus();
+ }
+
+ } else if (ev.key === "ArrowLeft") {
+ const prevTab = tab.parentElement;
+
+ if (prevTab.previousElementSibling === null) {
+ tab.parentElement.parentElement.lastElementChild.firstElementChild.focus();
+ } else {
+ prevTab.previousElementSibling.firstElementChild.focus();
+ }
+ } else if (ev.key === "Tab" && !ev.shiftKey && ev.target === document.getElementById("tab-1")) {
+ document.getElementById("faqs").querySelector("[class='btn btn-primary']").focus();
+ } else if (ev.key === "Tab" && !ev.shiftKey && ev.target === document.getElementById("tab-2")) {
+ document.getElementById("report-bug").querySelector("[class='btn btn-primary']").focus();
+ } else if (ev.key === "Tab" && !ev.shiftKey && ev.target === document.getElementById("tab-3")) {
+ document.getElementById("about").querySelector("[href]").focus();
+ } else if (ev.key === "Tab" && !ev.shiftKey && ev.target === document.getElementById("tab-4")) {
+ const button = document.getElementById("support-modal").getElementsByClassName("modal-footer");
+ const close = button[0].firstElementChild;
+ close.focus();
+ } else if (ev.key === "Enter" || ev.key === "Space" || ev.key === " ") {
+ tab.click();
+ }
+ }
+
+ /**
+ * @param {Event} ev
+ */
+ navigateFAQList(ev) {
+
+ const el = ev.target.nextElementSibling;
+ if (ev.key === "Enter" || ev.key === "Space" || ev.key === " ") {
+ ev.preventDefault();
+ const question = el.classList;
+ if (question !== undefined && question.value) {
+ if (!question.value.includes("show")) {
+ question.add("show");
+ } else if (question.contains("show")) {
+ question.remove("show");
+ }
+ }
+ }
+ }
+
/**
* Shows the stale indicator to show that the input or recipe has changed
* since the last bake.
@@ -410,6 +537,17 @@ ${navigator.userAgent}
}
}
+ /**
+ * Calculates the height of the controls area and adjusts the recipe
+ * height accordingly.
+ */
+ calcControlsHeight() {
+ const controls = document.getElementById("controls"),
+ recList = document.getElementById("rec-list");
+
+ recList.style.bottom = controls.clientHeight + "px";
+ }
+
}
export default ControlsWaiter;
diff --git a/src/web/waiters/HighlighterWaiter.mjs b/src/web/waiters/HighlighterWaiter.mjs
index 664daef8..20ad0c6a 100755
--- a/src/web/waiters/HighlighterWaiter.mjs
+++ b/src/web/waiters/HighlighterWaiter.mjs
@@ -4,18 +4,8 @@
* @license Apache-2.0
*/
-/**
- * HighlighterWaiter data type enum for the input.
- * @enum
- */
-const INPUT = 0;
-
-/**
- * HighlighterWaiter data type enum for the output.
- * @enum
- */
-const OUTPUT = 1;
-
+import {EditorSelection} from "@codemirror/state";
+import {chrEncWidth} from "../../core/lib/ChrEnc.mjs";
/**
* Waiter to handle events related to highlighting in CyberChef.
@@ -32,436 +22,115 @@ class HighlighterWaiter {
this.app = app;
this.manager = manager;
- this.mouseButtonDown = false;
- this.mouseTarget = null;
+ this.currentSelectionRanges = [];
}
-
/**
- * Determines if the current text selection is running backwards or forwards.
- * StackOverflow answer id: 12652116
+ * Handler for selection change events in the input and output
*
- * @private
- * @returns {boolean}
- */
- _isSelectionBackwards() {
- let backwards = false;
- const sel = window.getSelection();
-
- if (!sel.isCollapsed) {
- const range = document.createRange();
- range.setStart(sel.anchorNode, sel.anchorOffset);
- range.setEnd(sel.focusNode, sel.focusOffset);
- backwards = range.collapsed;
- range.detach();
- }
- return backwards;
- }
-
-
- /**
- * Calculates the text offset of a position in an HTML element, ignoring HTML tags.
- *
- * @private
- * @param {element} node - The parent HTML node.
- * @param {number} offset - The offset since the last HTML element.
- * @returns {number}
- */
- _getOutputHtmlOffset(node, offset) {
- const sel = window.getSelection();
- const range = document.createRange();
-
- range.selectNodeContents(document.getElementById("output-html"));
- range.setEnd(node, offset);
- sel.removeAllRanges();
- sel.addRange(range);
-
- return sel.toString().length;
- }
-
-
- /**
- * Gets the current selection offsets in the output HTML, ignoring HTML tags.
- *
- * @private
- * @returns {Object} pos
- * @returns {number} pos.start
- * @returns {number} pos.end
- */
- _getOutputHtmlSelectionOffsets() {
- const sel = window.getSelection();
- let range,
- start = 0,
- end = 0,
- backwards = false;
-
- if (sel.rangeCount) {
- range = sel.getRangeAt(sel.rangeCount - 1);
- backwards = this._isSelectionBackwards();
- start = this._getOutputHtmlOffset(range.startContainer, range.startOffset);
- end = this._getOutputHtmlOffset(range.endContainer, range.endOffset);
- sel.removeAllRanges();
- sel.addRange(range);
-
- if (backwards) {
- // If selecting backwards, reverse the start and end offsets for the selection to
- // prevent deselecting as the drag continues.
- sel.collapseToEnd();
- sel.extend(sel.anchorNode, range.startOffset);
- }
- }
-
- return {
- start: start,
- end: end
- };
- }
-
-
- /**
- * Handler for input scroll events.
- * Scrolls the highlighter pane to match the input textarea position.
- *
- * @param {event} e
- */
- inputScroll(e) {
- const el = e.target;
- document.getElementById("input-highlighter").scrollTop = el.scrollTop;
- document.getElementById("input-highlighter").scrollLeft = el.scrollLeft;
- }
-
-
- /**
- * Handler for output scroll events.
- * Scrolls the highlighter pane to match the output textarea position.
- *
- * @param {event} e
- */
- outputScroll(e) {
- const el = e.target;
- document.getElementById("output-highlighter").scrollTop = el.scrollTop;
- document.getElementById("output-highlighter").scrollLeft = el.scrollLeft;
- }
-
-
- /**
- * Handler for input mousedown events.
- * Calculates the current selection info, and highlights the corresponding data in the output.
- *
- * @param {event} e
- */
- inputMousedown(e) {
- this.mouseButtonDown = true;
- this.mouseTarget = INPUT;
- this.removeHighlights();
-
- const el = e.target;
- const start = el.selectionStart;
- const end = el.selectionEnd;
-
- if (start !== 0 || end !== 0) {
- document.getElementById("input-selection-info").innerHTML = this.selectionInfo(start, end);
- this.highlightOutput([{start: start, end: end}]);
- }
- }
-
-
- /**
- * Handler for output mousedown events.
- * Calculates the current selection info, and highlights the corresponding data in the input.
- *
- * @param {event} e
- */
- outputMousedown(e) {
- this.mouseButtonDown = true;
- this.mouseTarget = OUTPUT;
- this.removeHighlights();
-
- const el = e.target;
- const start = el.selectionStart;
- const end = el.selectionEnd;
-
- if (start !== 0 || end !== 0) {
- document.getElementById("output-selection-info").innerHTML = this.selectionInfo(start, end);
- this.highlightInput([{start: start, end: end}]);
- }
- }
-
-
- /**
- * Handler for output HTML mousedown events.
- * Calculates the current selection info.
- *
- * @param {event} e
- */
- outputHtmlMousedown(e) {
- this.mouseButtonDown = true;
- this.mouseTarget = OUTPUT;
-
- const sel = this._getOutputHtmlSelectionOffsets();
- if (sel.start !== 0 || sel.end !== 0) {
- document.getElementById("output-selection-info").innerHTML = this.selectionInfo(sel.start, sel.end);
- }
- }
-
-
- /**
- * Handler for input mouseup events.
- *
- * @param {event} e
- */
- inputMouseup(e) {
- this.mouseButtonDown = false;
- }
-
-
- /**
- * Handler for output mouseup events.
- *
- * @param {event} e
- */
- outputMouseup(e) {
- this.mouseButtonDown = false;
- }
-
-
- /**
- * Handler for output HTML mouseup events.
- *
- * @param {event} e
- */
- outputHtmlMouseup(e) {
- this.mouseButtonDown = false;
- }
-
-
- /**
- * Handler for input mousemove events.
- * Calculates the current selection info, and highlights the corresponding data in the output.
- *
- * @param {event} e
- */
- inputMousemove(e) {
- // Check that the left mouse button is pressed
- if (!this.mouseButtonDown ||
- e.which !== 1 ||
- this.mouseTarget !== INPUT)
- return;
-
- const el = e.target;
- const start = el.selectionStart;
- const end = el.selectionEnd;
-
- if (start !== 0 || end !== 0) {
- document.getElementById("input-selection-info").innerHTML = this.selectionInfo(start, end);
- this.highlightOutput([{start: start, end: end}]);
- }
- }
-
-
- /**
- * Handler for output mousemove events.
- * Calculates the current selection info, and highlights the corresponding data in the input.
- *
- * @param {event} e
- */
- outputMousemove(e) {
- // Check that the left mouse button is pressed
- if (!this.mouseButtonDown ||
- e.which !== 1 ||
- this.mouseTarget !== OUTPUT)
- return;
-
- const el = e.target;
- const start = el.selectionStart;
- const end = el.selectionEnd;
-
- if (start !== 0 || end !== 0) {
- document.getElementById("output-selection-info").innerHTML = this.selectionInfo(start, end);
- this.highlightInput([{start: start, end: end}]);
- }
- }
-
-
- /**
- * Handler for output HTML mousemove events.
- * Calculates the current selection info.
- *
- * @param {event} e
- */
- outputHtmlMousemove(e) {
- // Check that the left mouse button is pressed
- if (!this.mouseButtonDown ||
- e.which !== 1 ||
- this.mouseTarget !== OUTPUT)
- return;
-
- const sel = this._getOutputHtmlSelectionOffsets();
- if (sel.start !== 0 || sel.end !== 0) {
- document.getElementById("output-selection-info").innerHTML = this.selectionInfo(sel.start, sel.end);
- }
- }
-
-
- /**
- * Given start and end offsets, writes the HTML for the selection info element with the correct
- * padding.
- *
- * @param {number} start - The start offset.
- * @param {number} end - The end offset.
- * @returns {string}
- */
- selectionInfo(start, end) {
- const len = end.toString().length;
- const width = len < 2 ? 2 : len;
- const startStr = start.toString().padStart(width, " ").replace(/ /g, " ");
- const endStr = end.toString().padStart(width, " ").replace(/ /g, " ");
- const lenStr = (end-start).toString().padStart(width, " ").replace(/ /g, " ");
-
- return "start: " + startStr + "
end: " + endStr + "
length: " + lenStr; - } - - - /** - * Removes highlighting and selection information. - */ - removeHighlights() { - document.getElementById("input-highlighter").innerHTML = ""; - document.getElementById("output-highlighter").innerHTML = ""; - document.getElementById("input-selection-info").innerHTML = ""; - document.getElementById("output-selection-info").innerHTML = ""; - } - - - /** - * Highlights the given offsets in the output. + * Highlights the given offsets in the input or output. * We will only highlight if: * - input hasn't changed since last bake * - last bake was a full bake * - all operations in the recipe support highlighting * - * @param {Object} pos - The position object for the highlight. - * @param {number} pos.start - The start offset. - * @param {number} pos.end - The end offset. + * @param {string} io + * @param {ViewUpdate} e */ - highlightOutput(pos) { + selectionChange(io, e) { + // Confirm we are not currently baking if (!this.app.autoBake_ || this.app.baking) return false; - this.manager.worker.highlight(this.app.getRecipeConfig(), "forward", pos); + + // Confirm this was a user-generated event to prevent looping + // from setting the selection in this class + if (!e.transactions[0].isUserEvent("select")) return false; + + this.currentSelectionRanges = []; + + // Confirm some non-empty ranges are set + const selectionRanges = e.state.selection.ranges; + + // Adjust offsets based on the width of the character set + const inputCharacterWidth = chrEncWidth(this.manager.input.getChrEnc()); + const outputCharacterWidth = chrEncWidth(this.manager.output.getChrEnc()); + let ratio = 1; + if (inputCharacterWidth !== outputCharacterWidth && + inputCharacterWidth !== 0 && outputCharacterWidth !== 0) { + ratio = io === "input" ? + inputCharacterWidth / outputCharacterWidth : + outputCharacterWidth / inputCharacterWidth; + } + + // Loop through ranges and send request for output offsets for each one + const direction = io === "input" ? "forward" : "reverse"; + for (const range of selectionRanges) { + const pos = [{ + start: Math.floor(range.from * ratio), + end: Math.floor(range.to * ratio) + }]; + this.manager.worker.highlight(this.app.getRecipeConfig(), direction, pos); + } } - - /** - * Highlights the given offsets in the input. - * We will only highlight if: - * - input hasn't changed since last bake - * - last bake was a full bake - * - all operations in the recipe support highlighting - * - * @param {Object} pos - The position object for the highlight. - * @param {number} pos.start - The start offset. - * @param {number} pos.end - The end offset. - */ - highlightInput(pos) { - if (!this.app.autoBake_ || this.app.baking) return false; - this.manager.worker.highlight(this.app.getRecipeConfig(), "reverse", pos); - } - - /** * Displays highlight offsets sent back from the Chef. * - * @param {Object} pos - The position object for the highlight. + * @param {Object[]} pos - The position object for the highlight. * @param {number} pos.start - The start offset. * @param {number} pos.end - The end offset. * @param {string} direction */ displayHighlights(pos, direction) { if (!pos) return; - - if (this.manager.tabs.getActiveInputTab() !== this.manager.tabs.getActiveOutputTab()) return; + if (this.manager.tabs.getActiveTab("input") !== this.manager.tabs.getActiveTab("output")) return; const io = direction === "forward" ? "output" : "input"; - - document.getElementById(io + "-selection-info").innerHTML = this.selectionInfo(pos[0].start, pos[0].end); - this.highlight( - document.getElementById(io + "-text"), - document.getElementById(io + "-highlighter"), - pos); + this.highlight(io, pos); } - /** - * Adds the relevant HTML to the specified highlight element such that highlighting appears - * underneath the correct offset. + * Sends selection updates to the relevant EditorView. * - * @param {element} textarea - The input or output textarea. - * @param {element} highlighter - The input or output highlighter element. - * @param {Object} pos - The position object for the highlight. - * @param {number} pos.start - The start offset. - * @param {number} pos.end - The end offset. + * @param {string} io - The input or output + * @param {Object[]} ranges - An array of position objects to highlight + * @param {number} ranges.start - The start offset + * @param {number} ranges.end - The end offset */ - async highlight(textarea, highlighter, pos) { + async highlight(io, ranges) { if (!this.app.options.showHighlighter) return false; if (!this.app.options.attemptHighlight) return false; + if (!ranges || !ranges.length) return false; - // Check if there is a carriage return in the output dish as this will not - // be displayed by the HTML textarea and will mess up highlighting offsets. - if (await this.manager.output.containsCR()) return false; + const view = io === "input" ? + this.manager.input.inputEditorView : + this.manager.output.outputEditorView; - const startPlaceholder = "[startHighlight]"; - const startPlaceholderRegex = /\[startHighlight\]/g; - const endPlaceholder = "[endHighlight]"; - const endPlaceholderRegex = /\[endHighlight\]/g; - let text = textarea.value; + // Add new SelectionRanges to existing ones + for (const range of ranges) { + if (typeof range.start !== "number" || + typeof range.end !== "number") + continue; + const selection = range.end <= range.start ? + EditorSelection.cursor(range.start) : + EditorSelection.range(range.start, range.end); - // Put placeholders in position - // If there's only one value, select that - // If there are multiple, ignore the first one and select all others - if (pos.length === 1) { - if (pos[0].end < pos[0].start) return; - text = text.slice(0, pos[0].start) + - startPlaceholder + text.slice(pos[0].start, pos[0].end) + endPlaceholder + - text.slice(pos[0].end, text.length); - } else { - // O(n^2) - Can anyone improve this without overwriting placeholders? - let result = "", - endPlaced = true; - - for (let i = 0; i < text.length; i++) { - for (let j = 1; j < pos.length; j++) { - if (pos[j].end < pos[j].start) continue; - if (pos[j].start === i) { - result += startPlaceholder; - endPlaced = false; - } - if (pos[j].end === i) { - result += endPlaceholder; - endPlaced = true; - } - } - result += text[i]; - } - if (!endPlaced) result += endPlaceholder; - text = result; + this.currentSelectionRanges.push(selection); } - const cssClass = "hl1"; - - // Remove HTML tags - text = text - .replace(/&/g, "&") - .replace(//g, ">") - .replace(/\n/g, " ") - // Convert placeholders to tags - .replace(startPlaceholderRegex, "") - .replace(endPlaceholderRegex, "") + " "; - - // Adjust width to allow for scrollbars - highlighter.style.width = textarea.clientWidth + "px"; - highlighter.innerHTML = text; - highlighter.scrollTop = textarea.scrollTop; - highlighter.scrollLeft = textarea.scrollLeft; + // Set selection + if (this.currentSelectionRanges.length) { + try { + view.dispatch({ + selection: EditorSelection.create(this.currentSelectionRanges), + scrollIntoView: true + }); + } catch (err) { + // Ignore Range Errors + if (!err.toString().startsWith("RangeError")) { + log.error(err); + } + } + } } } diff --git a/src/web/waiters/InputWaiter.mjs b/src/web/waiters/InputWaiter.mjs index b421d8d8..94663a0b 100644 --- a/src/web/waiters/InputWaiter.mjs +++ b/src/web/waiters/InputWaiter.mjs @@ -7,9 +7,42 @@ import LoaderWorker from "worker-loader?inline=no-fallback!../workers/LoaderWorker.js"; import InputWorker from "worker-loader?inline=no-fallback!../workers/InputWorker.mjs"; -import Utils, { debounce } from "../../core/Utils.mjs"; -import { toBase64 } from "../../core/lib/Base64.mjs"; -import { isImage } from "../../core/lib/FileType.mjs"; +import Utils, {debounce} from "../../core/Utils.mjs"; +import {toBase64} from "../../core/lib/Base64.mjs"; +import cptable from "codepage"; + +import { + EditorView, + keymap, + highlightSpecialChars, + drawSelection, + rectangularSelection, + crosshairCursor, + dropCursor +} from "@codemirror/view"; +import { + EditorState, + Compartment +} from "@codemirror/state"; +import { + defaultKeymap, + insertTab, + insertNewline, + history, + historyKeymap +} from "@codemirror/commands"; +import { + bracketMatching +} from "@codemirror/language"; +import { + search, + searchKeymap, + highlightSelectionMatches +} from "@codemirror/search"; + +import {statusBar} from "../utils/statusBar.mjs"; +import {fileDetailsPanel} from "../utils/fileDetails.mjs"; +import {eolCodeToSeq, eolCodeToName, renderSpecialChar} from "../utils/editorUtils.mjs"; /** @@ -27,23 +60,11 @@ class InputWaiter { this.app = app; this.manager = manager; - // Define keys that don't change the input so we don't have to autobake when they are pressed - this.badKeys = [ - 16, // Shift - 17, // Ctrl - 18, // Alt - 19, // Pause - 20, // Caps - 27, // Esc - 33, 34, 35, 36, // PgUp, PgDn, End, Home - 37, 38, 39, 40, // Directional - 44, // PrntScrn - 91, 92, // Win - 93, // Context - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, // F1-12 - 144, // Num - 145, // Scroll - ]; + this.inputTextEl = document.getElementById("input-text"); + this.inputChrEnc = 0; + this.eolState = 0; // 0 = unset, 1 = detected, 2 = manual + this.encodingState = 0; // 0 = unset, 1 = detected, 2 = manual + this.initEditor(); this.inputWorker = null; this.loaderWorkers = []; @@ -51,6 +72,7 @@ class InputWaiter { this.maxTabs = this.manager.tabs.calcMaxTabs(); this.callbacks = {}; this.callbackID = 0; + this.fileDetails = {}; this.maxWorkers = 1; if (navigator.hardwareConcurrency !== undefined && @@ -61,6 +83,251 @@ class InputWaiter { } } + /** + * Sets up the CodeMirror Editor + */ + initEditor() { + // Mutable extensions + this.inputEditorConf = { + eol: new Compartment, + lineWrapping: new Compartment, + fileDetailsPanel: new Compartment + }; + + const self = this; + const initialState = EditorState.create({ + doc: null, + extensions: [ + // Editor extensions + history(), + highlightSpecialChars({ + render: renderSpecialChar // Custom character renderer to handle special cases + }), + drawSelection(), + rectangularSelection(), + crosshairCursor(), + dropCursor(), + bracketMatching(), + highlightSelectionMatches(), + search({top: true}), + EditorState.allowMultipleSelections.of(true), + + // Custom extensions + statusBar({ + label: "Input", + eolHandler: this.eolChange.bind(this), + chrEncHandler: this.chrEncChange.bind(this), + chrEncGetter: this.getChrEnc.bind(this), + getEncodingState: this.getEncodingState.bind(this), + getEOLState: this.getEOLState.bind(this) + }), + + // Mutable state + this.inputEditorConf.fileDetailsPanel.of([]), + this.inputEditorConf.lineWrapping.of(EditorView.lineWrapping), + this.inputEditorConf.eol.of(EditorState.lineSeparator.of("\n")), + + // Keymap + keymap.of([ + // Explicitly insert a tab rather than indenting the line + { key: "Tab", run: insertTab }, + // Explicitly insert a new line (using the current EOL char) rather + // than messing around with indenting, which does not respect EOL chars + { key: "Enter", run: insertNewline }, + ...historyKeymap, + ...defaultKeymap, + ...searchKeymap + ]), + + // Event listeners + EditorView.updateListener.of(e => { + if (e.selectionSet) + this.manager.highlighter.selectionChange("input", e); + if (e.docChanged && !this.silentInputChange) + this.inputChange(e); + this.silentInputChange = false; + }), + + // Event handlers + EditorView.domEventHandlers({ + paste(event, view) { + const clipboardData = event.clipboardData; + const items = clipboardData.items; + let files = []; + for (let i = 0; i < items.length; i++) { + const item = items[i]; + if (item.kind === "string") { + // If there are any string items they should be preferred over + // files. + files = []; + break; + } else if (item.kind === "file") { + files.push(item.getAsFile()); + } + } + if (files.length > 0) { + // Prevent the default paste behavior, afterPaste will load the files instead + event.preventDefault(); + } + setTimeout(() => { + self.afterPaste(files); + }); + } + }) + ] + }); + + + if (this.inputEditorView) this.inputEditorView.destroy(); + this.inputEditorView = new EditorView({ + state: initialState, + parent: this.inputTextEl + }); + } + + /** + * Handler for EOL change events + * Sets the line separator + * @param {string} eol + * @param {boolean} [manual=false] + */ + eolChange(eol, manual=false) { + const eolVal = eolCodeToSeq[eol]; + if (eolVal === undefined) return; + + this.eolState = manual ? 2 : this.eolState; + if (this.eolState < 2 && eolVal === this.getEOLSeq()) return; + + if (this.eolState === 1) { + // Alert + this.app.alert(`Input end of line separator has been detected and changed to ${eolCodeToName[eol]}`, 5000); + } + + // Update the EOL value + const oldInputVal = this.getInput(); + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.eol.reconfigure(EditorState.lineSeparator.of(eolVal)) + }); + + // Reset the input so that lines are recalculated, preserving the old EOL values + this.setInput(oldInputVal); + } + + /** + * Getter for the input EOL sequence + * @returns {string} + */ + getEOLSeq() { + return this.inputEditorView.state.lineBreak; + } + + /** + * Returns whether the input EOL sequence was set manually or has been detected automatically + * @returns {number} - 0 = unset, 1 = detected, 2 = manual + */ + getEOLState() { + return this.eolState; + } + + /** + * Handler for Chr Enc change events + * Sets the input character encoding + * @param {number} chrEncVal + * @param {boolean} [manual=false] - Flag to indicate the encoding was set by the user + * @param {boolean} [internal=false] - Flag to indicate this was set internally, i.e. by loading from URI + */ + chrEncChange(chrEncVal, manual=false, internal=false) { + if (typeof chrEncVal !== "number") return; + this.inputChrEnc = chrEncVal; + this.encodingState = manual ? 2 : this.encodingState; + if (!internal) { + this.inputChange(); + } + } + + /** + * Getter for the input character encoding + * @returns {number} + */ + getChrEnc() { + return this.inputChrEnc; + } + + /** + * Returns whether the input character encoding was set manually or has been detected automatically + * @returns {number} - 0 = unset, 1 = detected, 2 = manual + */ + getEncodingState() { + return this.encodingState; + } + + /** + * Sets word wrap on the input editor + * @param {boolean} wrap + */ + setWordWrap(wrap) { + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.lineWrapping.reconfigure( + wrap ? EditorView.lineWrapping : [] + ) + }); + } + + /** + * Gets the value of the current input + * @returns {string} + */ + getInput() { + const doc = this.inputEditorView.state.doc; + const eol = this.getEOLSeq(); + return doc.sliceString(0, doc.length, eol); + } + + /** + * Sets the value of the current input + * @param {string} data + * @param {boolean} [silent=false] + */ + setInput(data, silent=false) { + const lineLengthThreshold = 131072; // 128KB + let wrap = this.app.options.wordWrap; + if (data.length > lineLengthThreshold) { + const lines = data.split(this.getEOLSeq()); + const longest = lines.reduce((a, b) => + a > b.length ? a : b.length, 0 + ); + if (longest > lineLengthThreshold) { + // If we are exceeding the max line length, turn off word wrap + wrap = false; + this.app.alert("Maximum line length exceeded. Word wrap will be temporarily disabled to improve performance.", 20000); + } + } + + // If turning word wrap off, do it before we populate the editor for performance reasons + if (!wrap) this.setWordWrap(wrap); + + // We use setTimeout here to delay the editor dispatch until the next event cycle, + // ensuring all async actions have completed before attempting to set the contents + // of the editor. This is mainly with the above call to setWordWrap() in mind. + setTimeout(() => { + // Insert data into editor, overwriting any previous contents + this.silentInputChange = silent; + this.inputEditorView.dispatch({ + changes: { + from: 0, + to: this.inputEditorView.state.doc.length, + insert: data + } + }); + + // If turning word wrap on, do it after we populate the editor + if (wrap) + setTimeout(() => { + this.setWordWrap(wrap); + }); + }); + } + /** * Calculates the maximum number of tabs to display */ @@ -72,7 +339,7 @@ class InputWaiter { action: "updateMaxTabs", data: { maxTabs: numTabs, - activeTab: this.manager.tabs.getActiveInputTab() + activeTab: this.manager.tabs.getActiveTab("input") } }); } @@ -93,6 +360,10 @@ class InputWaiter { log.debug("Adding new InputWorker"); this.inputWorker = new InputWorker(); + this.inputWorker.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); this.inputWorker.postMessage({ action: "updateMaxWorkers", data: this.maxWorkers @@ -101,13 +372,10 @@ class InputWaiter { action: "updateMaxTabs", data: { maxTabs: this.maxTabs, - activeTab: this.manager.tabs.getActiveInputTab() + activeTab: this.manager.tabs.getActiveTab("input") } }); - this.inputWorker.postMessage({ - action: "setLogLevel", - data: log.getLevel() - }); + this.inputWorker.addEventListener("message", this.handleInputWorkerMessage.bind(this)); } @@ -136,11 +404,20 @@ class InputWaiter { if (this.loaderWorkers.length === this.maxWorkers) { return -1; } - log.debug("Adding new LoaderWorker."); + log.debug(`Adding new LoaderWorker (${this.loaderWorkers.length + 1}/${this.maxWorkers}).`); const newWorker = new LoaderWorker(); const workerId = this.workerId++; newWorker.addEventListener("message", this.handleLoaderMessage.bind(this)); - newWorker.postMessage({id: workerId}); + newWorker.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); + newWorker.postMessage({ + action: "setID", + data: { + id: workerId + } + }); const newWorkerObj = { worker: newWorker, id: workerId @@ -205,8 +482,11 @@ class InputWaiter { const idx = this.getLoaderWorkerIndex(inputData.workerId); if (idx === -1) return; this.loaderWorkers[idx].worker.postMessage({ - file: inputData.file, - inputNum: inputData.inputNum + action: "loadFile", + data: { + file: inputData.file, + inputNum: inputData.inputNum + } }); } @@ -221,7 +501,7 @@ class InputWaiter { if (Object.prototype.hasOwnProperty.call(r, "progress") && Object.prototype.hasOwnProperty.call(r, "inputNum")) { - this.manager.tabs.updateInputTabProgress(r.inputNum, r.progress, 100); + this.manager.tabs.updateTabProgress(r.inputNum, r.progress, 100, "input"); } const transferable = Object.prototype.hasOwnProperty.call(r, "fileBuffer") ? [r.fileBuffer] : undefined; @@ -233,7 +513,7 @@ class InputWaiter { /** - * Handler for messages sent back by the inputWorker + * Handler for messages sent back by the InputWorker * * @param {MessageEvent} e */ @@ -245,7 +525,7 @@ class InputWaiter { return; } - log.debug(`Receiving ${r.action} from InputWorker.`); + log.debug(`Receiving '${r.action}' from InputWorker.`); switch (r.action) { case "activateLoaderWorker": @@ -264,13 +544,13 @@ class InputWaiter { this.changeTab(r.data, this.app.options.syncTabs); break; case "updateTabHeader": - this.manager.tabs.updateInputTabHeader(r.data.inputNum, r.data.input); + this.manager.tabs.updateTabHeader(r.data.inputNum, r.data.input, "input"); break; case "loadingInfo": this.showLoadingInfo(r.data, true); break; case "setInput": - debounce(this.set, 50, "setInput", this, [r.data.inputObj, r.data.silent])(); + this.set(r.data.inputNum, r.data.inputObj, r.data.silent); break; case "inputAdded": this.inputAdded(r.data.changeTab, r.data.inputNum); @@ -281,8 +561,8 @@ class InputWaiter { case "queueInputError": this.manager.worker.queueInputError(r.data); break; - case "bakeAllInputs": - this.manager.worker.bakeAllInputs(r.data); + case "bakeInputs": + this.manager.worker.bakeInputs(r.data); break; case "displayTabSearchResults": this.displayTabSearchResults(r.data); @@ -291,10 +571,7 @@ class InputWaiter { this.app.handleError(r.data); break; case "setUrl": - this.setUrl(r.data); - break; - case "inputSwitch": - this.manager.output.inputSwitch(r.data); + this.app.updateURL(r.data.includeInput, r.data.input); break; case "getInput": case "getInputNums": @@ -325,99 +602,130 @@ class InputWaiter { /** * Sets the input in the input area * - * @param {object} inputData - Object containing the input and its metadata - * @param {number} inputData.inputNum - The unique inputNum for the selected input - * @param {string | object} inputData.input - The actual input data - * @param {string} inputData.name - The name of the input file - * @param {number} inputData.size - The size in bytes of the input file - * @param {string} inputData.type - The MIME type of the input file - * @param {number} inputData.progress - The load progress of the input file + * @param {number} inputNum + * @param {Object} inputData - Object containing the input and its metadata + * @param {string} type + * @param {ArrayBuffer} buffer + * @param {string} stringSample + * @param {Object} file + * @param {string} file.name + * @param {number} file.size + * @param {string} file.type + * @param {string} status + * @param {number} progress + * @param {number} encoding + * @param {string} eolSequence * @param {boolean} [silent=false] - If false, fires the manager statechange event */ - async set(inputData, silent=false) { + async set(inputNum, inputData, silent=false) { return new Promise(function(resolve, reject) { - const activeTab = this.manager.tabs.getActiveInputTab(); - if (inputData.inputNum !== activeTab) return; - - const inputText = document.getElementById("input-text"); - - if (typeof inputData.input === "string") { - inputText.value = inputData.input; - const fileOverlay = document.getElementById("input-file"), - fileName = document.getElementById("input-file-name"), - fileSize = document.getElementById("input-file-size"), - fileType = document.getElementById("input-file-type"), - fileLoaded = document.getElementById("input-file-loaded"); - - fileOverlay.style.display = "none"; - fileName.textContent = ""; - fileSize.textContent = ""; - fileType.textContent = ""; - fileLoaded.textContent = ""; - - inputText.style.overflow = "auto"; - inputText.classList.remove("blur"); - inputText.scroll(0, 0); - - const lines = inputData.input.length < (this.app.options.ioDisplayThreshold * 1024) ? - inputData.input.count("\n") + 1 : null; - this.setInputInfo(inputData.input.length, lines); - - // Set URL to current input - const inputStr = toBase64(inputData.input, "A-Za-z0-9+/"); - if (inputStr.length > 0 && inputStr.length <= 68267) { - this.setUrl({ - includeInput: true, - input: inputStr - }); - } - - if (!silent) window.dispatchEvent(this.manager.statechange); - } else { - this.setFile(inputData, silent); + const activeTab = this.manager.tabs.getActiveTab("input"); + if (inputNum !== activeTab) { + this.changeTab(inputNum, this.app.options.syncTabs); + return; } + // Update current character encoding + this.inputChrEnc = inputData.encoding; + + // Update current eol sequence + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.eol.reconfigure( + EditorState.lineSeparator.of(inputData.eolSequence) + ) + }); + + // Handle file previews + if (inputData.file) { + this.setFile(inputNum, inputData); + } else { + this.clearFile(inputNum); + } + + // Decode the data to a string + this.manager.timing.recordTime("inputEncodingStart", inputNum); + let inputVal; + if (this.getChrEnc() > 0) { + inputVal = cptable.utils.decode(this.inputChrEnc, new Uint8Array(inputData.buffer)); + } else { + inputVal = Utils.arrayBufferToStr(inputData.buffer); + } + this.manager.timing.recordTime("inputEncodingEnd", inputNum); + + // Populate the input editor + this.setInput(inputVal, silent); + + // Set URL to current input + if (inputVal.length >= 0 && inputVal.length <= 51200) { + const inputStr = toBase64(inputVal, "A-Za-z0-9+/"); + this.app.updateURL(true, inputStr); + } }.bind(this)); } /** * Displays file details * - * @param {object} inputData - Object containing the input and its metadata - * @param {number} inputData.inputNum - The unique inputNum for the selected input - * @param {string | object} inputData.input - The actual input data - * @param {string} inputData.name - The name of the input file - * @param {number} inputData.size - The size in bytes of the input file - * @param {string} inputData.type - The MIME type of the input file - * @param {number} inputData.progress - The load progress of the input file - * @param {boolean} [silent=true] - If false, fires the manager statechange event + * @param {number} inputNum + * @param {Object} inputData - Object containing the input and its metadata + * @param {string} type + * @param {ArrayBuffer} buffer + * @param {string} stringSample + * @param {Object} file + * @param {string} file.name + * @param {number} file.size + * @param {string} file.type + * @param {string} status + * @param {number} progress */ - setFile(inputData, silent=true) { - const activeTab = this.manager.tabs.getActiveInputTab(); - if (inputData.inputNum !== activeTab) return; + setFile(inputNum, inputData) { + const activeTab = this.manager.tabs.getActiveTab("input"); + if (inputNum !== activeTab) return; - const fileOverlay = document.getElementById("input-file"), - fileName = document.getElementById("input-file-name"), - fileSize = document.getElementById("input-file-size"), - fileType = document.getElementById("input-file-type"), - fileLoaded = document.getElementById("input-file-loaded"); + // Create file details panel + this.fileDetails = { + fileDetails: inputData.file, + progress: inputData.progress, + status: inputData.status, + buffer: inputData.buffer, + renderPreview: this.app.options.imagePreview, + toggleHandler: this.toggleFileDetails.bind(this), + hidden: false + }; + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.fileDetailsPanel.reconfigure( + fileDetailsPanel(this.fileDetails) + ) + }); + } - fileOverlay.style.display = "block"; - fileName.textContent = inputData.name; - fileSize.textContent = inputData.size + " bytes"; - fileType.textContent = inputData.type; - if (inputData.status === "error") { - fileLoaded.textContent = "Error"; - fileLoaded.style.color = "#FF0000"; - } else { - fileLoaded.style.color = ""; - fileLoaded.textContent = inputData.progress + "%"; - } + /** + * Clears the file details panel + * + * @param {number} inputNum + */ + clearFile(inputNum) { + const activeTab = this.manager.tabs.getActiveTab("input"); + if (inputNum !== activeTab) return; - this.setInputInfo(inputData.size, null); - this.displayFilePreview(inputData); + // Clear file details panel + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.fileDetailsPanel.reconfigure([]) + }); + } - if (!silent) window.dispatchEvent(this.manager.statechange); + /** + * Handler for file details toggle clicks + * @param {event} e + */ + toggleFileDetails(e) { + $("[data-toggle='tooltip']").tooltip("hide"); + this.fileDetails.hidden = !this.fileDetails.hidden; + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.fileDetailsPanel.reconfigure( + fileDetailsPanel(this.fileDetails) + ) + }); } /** @@ -426,9 +734,9 @@ class InputWaiter { * @param {number} inputNum - The inputNum of the input which has finished loading */ fileLoaded(inputNum) { - this.manager.tabs.updateInputTabProgress(inputNum, 100, 100); + this.manager.tabs.updateTabProgress(inputNum, 100, 100, "input"); - const activeTab = this.manager.tabs.getActiveInputTab(); + const activeTab = this.manager.tabs.getActiveTab("input"); if (activeTab !== inputNum) return; this.inputWorker.postMessage({ @@ -442,63 +750,6 @@ class InputWaiter { this.updateFileProgress(inputNum, 100); } - /** - * Render the input thumbnail - */ - async renderFileThumb() { - const activeTab = this.manager.tabs.getActiveInputTab(), - input = await this.getInputValue(activeTab), - fileThumb = document.getElementById("input-file-thumbnail"); - - if (typeof input === "string" || - !this.app.options.imagePreview) { - this.resetFileThumb(); - return; - } - - const inputArr = new Uint8Array(input), - type = isImage(inputArr); - - if (type && type !== "image/tiff" && inputArr.byteLength <= 512000) { - // Most browsers don't support displaying TIFFs, so ignore them - // Don't render images over 512000 bytes - const blob = new Blob([inputArr], {type: type}), - url = URL.createObjectURL(blob); - fileThumb.src = url; - } else { - this.resetFileThumb(); - } - - } - - /** - * Reset the input thumbnail to the default icon - */ - resetFileThumb() { - const fileThumb = document.getElementById("input-file-thumbnail"); - fileThumb.src = require("../static/images/file-128x128.png").default; - } - - /** - * Shows a chunk of the file in the input behind the file overlay - * - * @param {Object} inputData - Object containing the input data - * @param {number} inputData.inputNum - The inputNum of the file being displayed - * @param {ArrayBuffer} inputData.input - The actual input to display - */ - displayFilePreview(inputData) { - const activeTab = this.manager.tabs.getActiveInputTab(), - input = inputData.input, - inputText = document.getElementById("input-text"); - if (inputData.inputNum !== activeTab) return; - inputText.style.overflow = "hidden"; - inputText.classList.add("blur"); - inputText.value = Utils.printable(Utils.arrayBufferToStr(input.slice(0, 4096))); - - this.renderFileThumb(); - - } - /** * Updates the displayed load progress for a file * @@ -506,17 +757,16 @@ class InputWaiter { * @param {number | string} progress - Either a number or "error" */ updateFileProgress(inputNum, progress) { - const activeTab = this.manager.tabs.getActiveInputTab(); + const activeTab = this.manager.tabs.getActiveTab("input"); if (inputNum !== activeTab) return; - const fileLoaded = document.getElementById("input-file-loaded"); - if (progress === "error") { - fileLoaded.textContent = "Error"; - fileLoaded.style.color = "#FF0000"; - } else { - fileLoaded.textContent = progress + "%"; - fileLoaded.style.color = ""; - } + this.fileDetails.progress = progress; + if (progress === "error") this.fileDetails.status = "error"; + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.fileDetailsPanel.reconfigure( + fileDetailsPanel(this.fileDetails) + ) + }); } /** @@ -524,46 +774,44 @@ class InputWaiter { * * @param {number} inputNum * @param {string | ArrayBuffer} value - * @param {boolean} [force=false] - If true, forces the value to be updated even if the type is different to the currently stored type */ updateInputValue(inputNum, value, force=false) { - let includeInput = false; - const recipeStr = toBase64(value, "A-Za-z0-9+/"); // B64 alphabet with no padding - if (recipeStr.length > 0 && recipeStr.length <= 68267) { - includeInput = true; - } - this.setUrl({ - includeInput: includeInput, - input: recipeStr - }); + // Prepare the value as a buffer (full value) and a string sample (up to 4096 bytes) + let buffer; + let stringSample = ""; - // Value is either a string set by the input or an ArrayBuffer from a LoaderWorker, - // so is safe to use typeof === "string" - const transferable = (typeof value !== "string") ? [value] : undefined; + // If value is a string, interpret it using the specified character encoding + const tabNum = this.manager.tabs.getActiveTab("input"); + this.manager.timing.recordTime("inputEncodingStart", tabNum); + if (typeof value === "string") { + stringSample = value.slice(0, 4096); + if (this.getChrEnc() > 0) { + buffer = cptable.utils.encode(this.getChrEnc(), value); + buffer = new Uint8Array(buffer).buffer; + } else { + buffer = Utils.strToArrayBuffer(value); + } + } else { + buffer = value; + stringSample = Utils.arrayBufferToStr(value.slice(0, 4096)); + } + this.manager.timing.recordTime("inputEncodingEnd", tabNum); + + // Update the deep link + const recipeStr = buffer.byteLength < 51200 ? toBase64(buffer, "A-Za-z0-9+/") : ""; // B64 alphabet with no padding + const includeInput = recipeStr.length > 0 && buffer.byteLength < 51200; + this.app.updateURL(includeInput, recipeStr); + + // Post new value to the InputWorker + const transferable = [buffer]; this.inputWorker.postMessage({ action: "updateInputValue", data: { inputNum: inputNum, - value: value, - force: force - } - }, transferable); - } - - /** - * Updates the .data property for the input of the specified inputNum. - * Used for switching the output into the input - * - * @param {number} inputNum - The inputNum of the input we're changing - * @param {object} inputData - The new data object - */ - updateInputObj(inputNum, inputData) { - const transferable = (typeof inputData !== "string") ? [inputData.fileBuffer] : undefined; - this.inputWorker.postMessage({ - action: "updateInputObj", - data: { - inputNum: inputNum, - data: inputData + buffer: buffer, + stringSample: stringSample, + encoding: this.getChrEnc(), + eolSequence: this.getEOLSeq() } }, transferable); } @@ -576,7 +824,7 @@ class InputWaiter { */ async getInputValue(inputNum) { return await new Promise(resolve => { - this.getInput(inputNum, false, r => { + this.getInputFromWorker(inputNum, false, r => { resolve(r.data); }); }); @@ -590,7 +838,7 @@ class InputWaiter { */ async getInputObj(inputNum) { return await new Promise(resolve => { - this.getInput(inputNum, true, r => { + this.getInputFromWorker(inputNum, true, r => { resolve(r.data); }); }); @@ -604,7 +852,7 @@ class InputWaiter { * @param {Function} callback - The callback to execute when the input is returned * @returns {ArrayBuffer | string | object} */ - getInput(inputNum, getObj, callback) { + getInputFromWorker(inputNum, getObj, callback) { const id = this.callbackID++; this.callbacks[id] = callback; @@ -647,129 +895,91 @@ class InputWaiter { }); } - - /** - * Displays information about the input. - * - * @param {number} length - The length of the current input string - * @param {number} lines - The number of the lines in the current input string - */ - setInputInfo(length, lines) { - let width = length.toString().length.toLocaleString(); - width = width < 2 ? 2 : width; - - const lengthStr = length.toString().padStart(width, " ").replace(/ /g, " "); - let msg = "length: " + lengthStr; - - if (typeof lines === "number") { - const linesStr = lines.toString().padStart(width, " ").replace(/ /g, " "); - msg += "
lines: " + linesStr; - } - - document.getElementById("input-info").innerHTML = msg; - - } - - /** - * Handler for input change events. - * Debounces the input so we don't call autobake too often. - * - * @param {event} e - */ - debounceInputChange(e) { - debounce(this.inputChange, 50, "inputChange", this, [e])(); - } - /** * Handler for input change events. * Updates the value stored in the inputWorker + * Debounces the input so we don't call autobake too often. * * @param {event} e * * @fires Manager#statechange */ inputChange(e) { - // Ignore this function if the input is a file - const fileOverlay = document.getElementById("input-file"); - if (fileOverlay.style.display === "block") return; + // Change debounce delay based on input length + const inputLength = this.inputEditorView.state.doc.length; + let delay; + if (inputLength < 10000) delay = 20; + else if (inputLength < 100000) delay = 50; + else if (inputLength < 1000000) delay = 200; + else delay = 500; - // Remove highlighting from input and output panes as the offsets might be different now - this.manager.highlighter.removeHighlights(); + debounce(function(e) { + const value = this.getInput(); + const activeTab = this.manager.tabs.getActiveTab("input"); - const textArea = document.getElementById("input-text"); - const value = (textArea.value !== undefined) ? textArea.value : ""; - const activeTab = this.manager.tabs.getActiveInputTab(); + this.updateInputValue(activeTab, value); + this.inputWorker.postMessage({ + action: "updateTabHeader", + data: activeTab + }); - this.app.progress = 0; - - const lines = value.length < (this.app.options.ioDisplayThreshold * 1024) ? - (value.count("\n") + 1) : null; - this.setInputInfo(value.length, lines); - this.updateInputValue(activeTab, value); - this.manager.tabs.updateInputTabHeader(activeTab, value.replace(/[\n\r]/g, "").slice(0, 100)); - - if (e && this.badKeys.indexOf(e.keyCode) < 0) { // Fire the statechange event as the input has been modified window.dispatchEvent(this.manager.statechange); - } + }, delay, "inputChange", this, [e])(); } /** - * Handler for input paste events - * Checks that the size of the input is below the display limit, otherwise treats it as a file/blob + * Handler that fires just after input paste events. + * Checks whether the EOL separator or character encoding should be updated. * - * @param {event} e + * @param {File[]} files - An array of any files that were included in the paste event */ - async inputPaste(e) { - e.preventDefault(); - e.stopPropagation(); + afterPaste(files) { + if (files.length > 0) { + this.loadUIFiles(files); + } + // If EOL has been fixed, skip this. + if (this.eolState > 1) return; - const self = this; - /** - * Triggers the input file/binary data overlay - * - * @param {string} pastedData - */ - function triggerOverlay(pastedData) { - const file = new File([pastedData], "PastedData", { - type: "text/plain", - lastModified: Date.now() - }); + const inputText = this.getInput(); - self.loadUIFiles([file]); + // Detect most likely EOL sequence + const eolCharCounts = { + "LF": inputText.count("\u000a"), + "VT": inputText.count("\u000b"), + "FF": inputText.count("\u000c"), + "CR": inputText.count("\u000d"), + "CRLF": inputText.count("\u000d\u000a"), + "NEL": inputText.count("\u0085"), + "LS": inputText.count("\u2028"), + "PS": inputText.count("\u2029") + }; + + // If all zero, leave alone + const total = Object.values(eolCharCounts).reduce((acc, curr) => { + return acc + curr; + }, 0); + if (total === 0) return; + + // Find most prevalent line ending sequence + const highest = Object.entries(eolCharCounts).reduce((acc, curr) => { + return curr[1] > acc[1] ? curr : acc; + }, ["LF", 0]); + let choice = highest[0]; + + // If CRLF not zero and more than half the highest alternative, choose CRLF + if ((eolCharCounts.CRLF * 2) > highest[1]) { + choice = "CRLF"; } - const pastedData = e.clipboardData.getData("Text"); - const inputText = document.getElementById("input-text"); - const selStart = inputText.selectionStart; - const selEnd = inputText.selectionEnd; - const startVal = inputText.value.slice(0, selStart); - const endVal = inputText.value.slice(selEnd); - const val = startVal + pastedData + endVal; + const eolVal = eolCodeToSeq[choice]; + if (eolVal === this.getEOLSeq()) return; - if (val.length >= (this.app.options.ioDisplayThreshold * 1024)) { - // Data too large to display, use overlay - triggerOverlay(val); - return false; - } else if (await this.preserveCarriageReturns(val)) { - // Data contains a carriage return and the user doesn't wish to edit it, use overlay - // We check this in a separate condition to make sure it is not run unless absolutely - // necessary. - triggerOverlay(val); - return false; - } else { - // Pasting normally fires the inputChange() event before - // changing the value, so instead change it here ourselves - // and manually fire inputChange() - inputText.value = val; - inputText.setSelectionRange(selStart + pastedData.length, selStart + pastedData.length); - // Don't debounce here otherwise the keyup event for the Ctrl key will cancel an autobake - // (at least for large inputs) - this.inputChange(e, true); - } + // Setting automatically + this.eolState = 1; + this.eolChange(choice); } - /** * Handler for input dragover events. * Gives the user a visual cue to show that items can be dropped here. @@ -783,7 +993,7 @@ class InputWaiter { e.stopPropagation(); e.preventDefault(); - e.target.closest("#input-text,#input-file").classList.add("dropping-file"); + e.target.closest("#input-text").classList.add("dropping-file"); } /** @@ -795,7 +1005,12 @@ class InputWaiter { inputDragleave(e) { e.stopPropagation(); e.preventDefault(); - e.target.closest("#input-text,#input-file").classList.remove("dropping-file"); + + // Dragleave often fires when moving between lines in the editor. + // If the from element is within the input-text element, we are still on target. + if (!this.inputTextEl.contains(e.fromElement)) { + e.target.closest("#input-text").classList.remove("dropping-file"); + } } /** @@ -804,27 +1019,107 @@ class InputWaiter { * * @param {event} e */ - inputDrop(e) { + async inputDrop(e) { // This will be set if we're dragging an operation if (e.dataTransfer.effectAllowed === "move") return false; e.stopPropagation(); e.preventDefault(); + e.target.closest("#input-text").classList.remove("dropping-file"); - const text = e.dataTransfer.getData("Text"); + // Dropped text is handled by the editor itself + if (e.dataTransfer.getData("Text")) return; - e.target.closest("#input-text,#input-file").classList.remove("dropping-file"); + // Dropped files + if (e?.dataTransfer?.files?.length > 0) { + let files = []; - if (text) { - // Append the text to the current input and fire inputChange() - document.getElementById("input-text").value += text; - this.inputChange(e); - return; + // Handling the files as FileSystemEntry objects allows us to open directories, + // but relies on a function that may be deprecated in future. + if (Object.prototype.hasOwnProperty.call(DataTransferItem.prototype, "webkitGetAsEntry")) { + const fileEntries = await this.getAllFileEntries(e.dataTransfer.items); + // Read all FileEntry objects into File objects + files = await Promise.all(fileEntries.map(async fe => await this.getFile(fe))); + } else { + files = e.dataTransfer.files; + } + + this.loadUIFiles(files); } + } - if (e.dataTransfer.files && e.dataTransfer.files.length > 0) { - this.loadUIFiles(e.dataTransfer.files); + /** + * + * @param {DataTransferItemList} dataTransferItemList + * @returns {FileSystemEntry[]} + */ + async getAllFileEntries(dataTransferItemList) { + const fileEntries = []; + // Use BFS to traverse entire directory/file structure + const queue = []; + // Unfortunately dataTransferItemList is not iterable i.e. no forEach + for (let i = 0; i < dataTransferItemList.length; i++) { + // Note webkitGetAsEntry a non-standard feature and may change + // Usage is necessary for handling directories + queue.push(dataTransferItemList[i].webkitGetAsEntry()); + } + while (queue.length > 0) { + const entry = queue.shift(); + if (entry.isFile) { + fileEntries.push(entry); + } else if (entry.isDirectory) { + queue.push(...await this.readAllDirectoryEntries(entry.createReader())); + } + } + return fileEntries; + } + + /** + * Get all the entries (files or sub-directories) in a directory by calling + * readEntries until it returns empty array + * + * @param {FileSystemDirectoryReader} directoryReader + * @returns {FileSystemEntry[]} + */ + async readAllDirectoryEntries(directoryReader) { + const entries = []; + let readEntries = await this.readEntriesPromise(directoryReader); + while (readEntries.length > 0) { + entries.push(...readEntries); + readEntries = await this.readEntriesPromise(directoryReader); + } + return entries; + } + + /** + * Wrap readEntries in a promise to make working with readEntries easier. + * readEntries will return only some of the entries in a directory + * e.g. Chrome returns at most 100 entries at a time + * + * @param {FileSystemDirectoryReader} directoryReader + * @returns {Promise} + */ + async readEntriesPromise(directoryReader) { + try { + return await new Promise((resolve, reject) => { + directoryReader.readEntries(resolve, reject); + }); + } catch (err) { + log.error(err); + } + } + + /** + * Reads a FileEntry and returns it as a File object + * @param {FileEntry} fileEntry + * @returns {File} + */ + async getFile(fileEntry) { + try { + return new Promise((resolve, reject) => fileEntry.file(resolve, reject)); + } catch (err) { + log.error(err); } } @@ -844,41 +1139,19 @@ class InputWaiter { } /** - * Checks if an input contains carriage returns. - * If a CR is detected, checks if the preserve CR option has been set, - * and if not, asks the user for their preference. - * - * @param {string} input - The input to be checked - * @returns {boolean} - If true, the input contains a CR which should be - * preserved, so display an overlay so it can't be edited + * Handler for open input button click. + * Opens the open file dialog. */ - async preserveCarriageReturns(input) { - if (input.indexOf("\r") < 0) return false; + inputOpenClick() { + document.getElementById("open-file").click(); + } - const optionsStr = "This behaviour can be changed in the Options pane"; - const preserveStr = `A carriage return (\\r, 0x0d) was detected in your input. To preserve it, editing has been disabled.
${optionsStr}`; - const dontPreserveStr = `A carriage return (\\r, 0x0d) was detected in your input. It has not been preserved.
${optionsStr}`; - - switch (this.app.options.preserveCR) { - case "always": - this.app.alert(preserveStr, 6000); - return true; - case "never": - this.app.alert(dontPreserveStr, 6000); - return false; - } - - // Only preserve for high-entropy inputs - const data = Utils.strToArrayBuffer(input); - const entropy = Utils.calculateShannonEntropy(data); - - if (entropy > 6) { - this.app.alert(preserveStr, 6000); - return true; - } - - this.app.alert(dontPreserveStr, 6000); - return false; + /** + * Handler for open folder button click + * Opens the open folder dialog. + */ + folderOpenClick() { + document.getElementById("open-folder").click(); } /** @@ -888,7 +1161,7 @@ class InputWaiter { */ loadUIFiles(files) { const numFiles = files.length; - const activeTab = this.manager.tabs.getActiveInputTab(); + const activeTab = this.manager.tabs.getActiveTab("input"); log.debug(`Loading ${numFiles} files.`); // Display the number of files as pending so the user @@ -913,22 +1186,6 @@ class InputWaiter { }); } - /** - * Handler for open input button click. - * Opens the open file dialog. - */ - inputOpenClick() { - document.getElementById("open-file").click(); - } - - /** - * Handler for open folder button click - * Opens the open folder dialog. - */ - folderOpenClick() { - document.getElementById("open-folder").click(); - } - /** * Display the loaded files information in the input header. * Also, sets the background of the Input header to be a progress bar @@ -987,7 +1244,7 @@ class InputWaiter { setTimeout(function() { this.inputWorker.postMessage({ action: "getLoadProgress", - data: this.manager.tabs.getActiveInputTab() + data: this.manager.tabs.getActiveTab("input") }); }.bind(this), 100); } @@ -999,9 +1256,9 @@ class InputWaiter { * @param {number} inputNum - The inputNum of the tab to change to * @param {boolean} [changeOutput=false] - If true, also changes the output */ - changeTab(inputNum, changeOutput) { - if (this.manager.tabs.getInputTabItem(inputNum) !== null) { - this.manager.tabs.changeInputTab(inputNum); + changeTab(inputNum, changeOutput=false) { + if (this.manager.tabs.getTabItem(inputNum, "input") !== null) { + this.manager.tabs.changeTab(inputNum, "input"); this.inputWorker.postMessage({ action: "setInput", data: { @@ -1010,7 +1267,7 @@ class InputWaiter { } }); } else { - const minNum = Math.min(...this.manager.tabs.getInputTabList()); + const minNum = Math.min(...this.manager.tabs.getTabList("input")); let direction = "right"; if (inputNum < minNum) { direction = "left"; @@ -1027,6 +1284,9 @@ class InputWaiter { if (changeOutput) { this.manager.output.changeTab(inputNum, false); } + + // Set cursor focus to current tab + this.inputEditorView.focus(); } /** @@ -1053,8 +1313,13 @@ class InputWaiter { this.manager.output.removeAllOutputs(); this.manager.output.terminateZipWorker(); - this.manager.highlighter.removeHighlights(); - getSelection().removeAllRanges(); + this.eolState = 0; + this.encodingState = 0; + this.manager.output.eolState = 0; + this.manager.output.encodingState = 0; + + this.initEditor(); + this.manager.output.initEditor(); const tabsList = document.getElementById("input-tabs"); const tabsListChildren = tabsList.children; @@ -1079,36 +1344,19 @@ class InputWaiter { this.setupInputWorker(); this.manager.worker.setupChefWorker(); this.addInput(true); - this.bakeAll(); } /** - * Handler for clear IO click event. - * Resets the input for the current tab + * Sets the console log level in the workers. */ - clearIoClick() { - const inputNum = this.manager.tabs.getActiveInputTab(); - if (inputNum === -1) return; - - this.manager.highlighter.removeHighlights(); - getSelection().removeAllRanges(); - - this.updateInputValue(inputNum, "", true); - - this.set({ - inputNum: inputNum, - input: "" + setLogLevel() { + this.loaderWorkers.forEach(w => { + w.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); }); - this.manager.tabs.updateInputTabHeader(inputNum, ""); - } - - /** - * Sets the console log level in the worker. - * - * @param {string} level - */ - setLogLevel(level) { if (!this.inputWorker) return; this.inputWorker.postMessage({ action: "setLogLevel", @@ -1163,12 +1411,12 @@ class InputWaiter { * @param {number} inputNum - The inputNum of the new tab * @param {boolean} [changeTab=true] - If true, changes to the new tab once it's been added */ - addTab(inputNum, changeTab = true) { + addTab(inputNum, changeTab=true) { const tabsWrapper = document.getElementById("input-tabs"), numTabs = tabsWrapper.children.length; - if (!this.manager.tabs.getInputTabItem(inputNum) && numTabs < this.maxTabs) { - const newTab = this.manager.tabs.createInputTabElement(inputNum, changeTab); + if (!this.manager.tabs.getTabItem(inputNum, "input") && numTabs < this.maxTabs) { + const newTab = this.manager.tabs.createTabElement(inputNum, changeTab, "input"); tabsWrapper.appendChild(newTab); if (numTabs > 0) { @@ -1198,7 +1446,7 @@ class InputWaiter { * @param {boolean} tabsRight - True if there are input tabs to the right of the displayed tabs */ refreshTabs(nums, activeTab, tabsLeft, tabsRight) { - this.manager.tabs.refreshInputTabs(nums, activeTab, tabsLeft, tabsRight); + this.manager.tabs.refreshTabs(nums, activeTab, tabsLeft, tabsRight, "input"); this.inputWorker.postMessage({ action: "setInput", @@ -1217,7 +1465,7 @@ class InputWaiter { */ removeInput(inputNum) { let refresh = false; - if (this.manager.tabs.getInputTabItem(inputNum) !== null) { + if (this.manager.tabs.getTabItem(inputNum, "input") !== null) { refresh = true; } this.inputWorker.postMessage({ @@ -1310,7 +1558,7 @@ class InputWaiter { * Changes to the next (right) tab */ changeTabRight() { - const activeTab = this.manager.tabs.getActiveInputTab(); + const activeTab = this.manager.tabs.getActiveTab("input"); if (activeTab === -1) return; this.inputWorker.postMessage({ action: "changeTabRight", @@ -1324,7 +1572,7 @@ class InputWaiter { * Changes to the previous (left) tab */ changeTabLeft() { - const activeTab = this.manager.tabs.getActiveInputTab(); + const activeTab = this.manager.tabs.getActiveTab("input"); if (activeTab === -1) return; this.inputWorker.postMessage({ action: "changeTabLeft", @@ -1339,7 +1587,7 @@ class InputWaiter { */ async goToTab() { const inputNums = await this.getInputNums(); - let tabNum = window.prompt(`Enter tab number (${inputNums.min} - ${inputNums.max}):`, this.manager.tabs.getActiveInputTab().toString()); + let tabNum = window.prompt(`Enter tab number (${inputNums.min} - ${inputNums.max}):`, this.manager.tabs.getActiveTab("input").toString()); if (tabNum === null) return; tabNum = parseInt(tabNum, 10); @@ -1428,17 +1676,22 @@ class InputWaiter { } /** - * Update the input URL to the new value - * - * @param {object} urlData - Object containing the URL data - * @param {boolean} urlData.includeInput - If true, the input is included in the title - * @param {string} urlData.input - The input data to be included + * Handler for incoming postMessages + * If the events data has a `type` property set to `dataSubmit` + * the value property is set to the current input + * @param {event} e + * @param {object} e.data + * @param {string} e.data.type - the type of request, currently the only value is "dataSubmit" + * @param {string} e.data.value - the value of the message */ - setUrl(urlData) { - this.app.updateTitle(urlData.includeInput, urlData.input, true); + handlePostMessage(e) { + log.debug(e); + if ("data" in e && "id" in e.data && "value" in e.data) { + if (e.data.id === "setInput") { + this.setInput(e.data.value); + } + } } - - } export default InputWaiter; diff --git a/src/web/waiters/OperationsWaiter.mjs b/src/web/waiters/OperationsWaiter.mjs index dee0dd06..6c2de064 100755 --- a/src/web/waiters/OperationsWaiter.mjs +++ b/src/web/waiters/OperationsWaiter.mjs @@ -28,17 +28,16 @@ class OperationsWaiter { this.removeIntent = false; } - /** * Handler for search events. * Finds operations which match the given search term and displays them under the search box. * - * @param {event} e + * @param {KeyboardEvent | ClipboardEvent | Event} e */ searchOperations(e) { let ops, selected; - if (e.type === "search" || e.keyCode === 13) { // Search or Return + if ((e.type === "search" && e.target.value !== "") || e.keyCode === 13) { // Search (non-empty) or Return e.preventDefault(); ops = document.querySelectorAll("#search-results li"); if (ops.length) { @@ -49,27 +48,43 @@ class OperationsWaiter { } } + /** + * Sets up the operation element with the correct attributes when selected + * @param {HTMLElement} element + */ + const _selectOperation = (element) => { + element.classList.add("selected-op"); + element.scrollIntoView({block: "nearest"}); + $(element).popover("show"); + e.target.setAttribute("aria-activedescendant", element.id); + }; + + /** + * Sets up the operation element with the correct attributes when deselected + * @param {HTMLElement} element + */ + const _deselectOperation = (element) => { + element.classList.remove("selected-op"); + $(element).popover("hide"); + }; + if (e.keyCode === 40) { // Down e.preventDefault(); ops = document.querySelectorAll("#search-results li"); if (ops.length) { selected = this.getSelectedOp(ops); - if (selected > -1) { - ops[selected].classList.remove("selected-op"); - } + if (selected > -1) _deselectOperation(ops[selected]); if (selected === ops.length-1) selected = -1; - ops[selected+1].classList.add("selected-op"); + _selectOperation(ops[selected+1]); } } else if (e.keyCode === 38) { // Up e.preventDefault(); ops = document.querySelectorAll("#search-results li"); if (ops.length) { selected = this.getSelectedOp(ops); - if (selected > -1) { - ops[selected].classList.remove("selected-op"); - } + if (selected > -1) _deselectOperation(ops[selected]); if (selected === 0) selected = ops.length; - ops[selected-1].classList.add("selected-op"); + _selectOperation(ops[selected-1]); } } else { const searchResultsEl = document.getElementById("search-results"); @@ -83,11 +98,13 @@ class OperationsWaiter { searchResultsEl.removeChild(searchResultsEl.firstChild); } + document.querySelector("#search").removeAttribute("aria-activedescendant"); + $("#categories .show").collapse("hide"); if (str) { const matchedOps = this.filterOperations(str, true); const matchedOpsHtml = matchedOps - .map(v => v.toStubHtml()) + .map((operation, idx) => operation.toStubHtml(false, `search-result-${idx}`)) .join(""); searchResultsEl.innerHTML = matchedOpsHtml; @@ -103,7 +120,7 @@ class OperationsWaiter { * @param {string} searchStr * @param {boolean} highlight - Whether or not to highlight the matching string in the operation * name and description - * @returns {string[]} + * @returns {HTMLOperation[]} */ filterOperations(inStr, highlight) { const matchedOps = []; @@ -168,6 +185,10 @@ class OperationsWaiter { */ opListCreate(e) { this.manager.recipe.createSortableSeedList(e.target); + + // Populate ops total + document.querySelector("#operations .title .op-count").innerText = Object.keys(this.app.operations).length; + this.enableOpsListPopovers(e.target); } @@ -293,6 +314,18 @@ class OperationsWaiter { this.app.resetFavourites(); } + + /** + * Sets whether operation counts are displayed next to a category title + */ + setCatCount() { + if (this.app.options.showCatCount) { + document.querySelectorAll(".category-title .op-count").forEach(el => el.classList.remove("hidden")); + } else { + document.querySelectorAll(".category-title .op-count").forEach(el => el.classList.add("hidden")); + } + } + } export default OperationsWaiter; diff --git a/src/web/waiters/OptionsWaiter.mjs b/src/web/waiters/OptionsWaiter.mjs old mode 100755 new mode 100644 index 5ef517d4..dcb0a5f4 --- a/src/web/waiters/OptionsWaiter.mjs +++ b/src/web/waiters/OptionsWaiter.mjs @@ -26,33 +26,31 @@ class OptionsWaiter { * @param {Object} options */ load(options) { - for (const option in options) { - this.app.options[option] = options[option]; - } + Object.assign(this.app.options, options); // Set options to match object - const cboxes = document.querySelectorAll("#options-body input[type=checkbox]"); - let i; - for (i = 0; i < cboxes.length; i++) { - cboxes[i].checked = this.app.options[cboxes[i].getAttribute("option")]; - } + document.querySelectorAll("#options-body input[type=checkbox]").forEach(cbox => { + cbox.checked = this.app.options[cbox.getAttribute("option")]; + }); - const nboxes = document.querySelectorAll("#options-body input[type=number]"); - for (i = 0; i < nboxes.length; i++) { - nboxes[i].value = this.app.options[nboxes[i].getAttribute("option")]; - nboxes[i].dispatchEvent(new CustomEvent("change", {bubbles: true})); - } + document.querySelectorAll("#options-body input[type=number]").forEach(nbox => { + nbox.value = this.app.options[nbox.getAttribute("option")]; + nbox.dispatchEvent(new CustomEvent("change", {bubbles: true})); + }); - const selects = document.querySelectorAll("#options-body select"); - for (i = 0; i < selects.length; i++) { - const val = this.app.options[selects[i].getAttribute("option")]; + document.querySelectorAll("#options-body select").forEach(select => { + const val = this.app.options[select.getAttribute("option")]; if (val) { - selects[i].value = val; - selects[i].dispatchEvent(new CustomEvent("change", {bubbles: true})); + select.value = val; + select.dispatchEvent(new CustomEvent("change", {bubbles: true})); } else { - selects[i].selectedIndex = 0; + select.selectedIndex = 0; } - } + }); + + // Initialise options + this.setWordWrap(); + this.manager.ops.setCatCount(); } @@ -136,19 +134,8 @@ class OptionsWaiter { * Sets or unsets word wrap on the input and output depending on the wordWrap option value. */ setWordWrap() { - document.getElementById("input-text").classList.remove("word-wrap"); - document.getElementById("output-text").classList.remove("word-wrap"); - document.getElementById("output-html").classList.remove("word-wrap"); - document.getElementById("input-highlighter").classList.remove("word-wrap"); - document.getElementById("output-highlighter").classList.remove("word-wrap"); - - if (!this.app.options.wordWrap) { - document.getElementById("input-text").classList.add("word-wrap"); - document.getElementById("output-text").classList.add("word-wrap"); - document.getElementById("output-html").classList.add("word-wrap"); - document.getElementById("input-highlighter").classList.add("word-wrap"); - document.getElementById("output-highlighter").classList.add("word-wrap"); - } + this.manager.input.setWordWrap(this.app.options.wordWrap); + this.manager.output.setWordWrap(this.app.options.wordWrap); } @@ -159,7 +146,6 @@ class OptionsWaiter { */ themeChange(e) { const themeClass = e.target.value; - this.changeTheme(themeClass); } @@ -174,9 +160,36 @@ class OptionsWaiter { // Update theme selection const themeSelect = document.getElementById("theme"); - themeSelect.selectedIndex = themeSelect.querySelector(`option[value="${theme}"`).index; + let themeOption = themeSelect.querySelector(`option[value="${theme}"]`); + + if (!themeOption) { + const preferredColorScheme = this.getPreferredColorScheme(); + document.querySelector(":root").className = preferredColorScheme; + themeOption = themeSelect.querySelector(`option[value="${preferredColorScheme}"]`); + } + + themeSelect.selectedIndex = themeOption.index; } + /** + * Applies the user's preferred color scheme using the `prefers-color-scheme` media query. + */ + applyPreferredColorScheme() { + const themeFromStorage = this.app?.options?.theme; + let theme = themeFromStorage; + if (!theme) { + theme = this.getPreferredColorScheme(); + } + this.changeTheme(theme); + } + + /** + * Get the user's preferred color scheme using the `prefers-color-scheme` media query. + */ + getPreferredColorScheme() { + const prefersDarkScheme = window.matchMedia("(prefers-color-scheme: dark)").matches; + return prefersDarkScheme ? "dark" : "classic"; + } /** * Changes the console logging level. @@ -188,6 +201,8 @@ class OptionsWaiter { log.setLevel(level, false); this.manager.worker.setLogLevel(); this.manager.input.setLogLevel(); + this.manager.output.setLogLevel(); + this.manager.background.setLogLevel(); } } diff --git a/src/web/waiters/OutputWaiter.mjs b/src/web/waiters/OutputWaiter.mjs index 0eb6baec..2b2cb096 100755 --- a/src/web/waiters/OutputWaiter.mjs +++ b/src/web/waiters/OutputWaiter.mjs @@ -5,11 +5,43 @@ * @license Apache-2.0 */ -import Utils, { debounce } from "../../core/Utils.mjs"; +import Utils, {debounce} from "../../core/Utils.mjs"; import Dish from "../../core/Dish.mjs"; +import {isUTF8, CHR_ENC_SIMPLE_REVERSE_LOOKUP} from "../../core/lib/ChrEnc.mjs"; +import {detectFileType} from "../../core/lib/FileType.mjs"; import FileSaver from "file-saver"; import ZipWorker from "worker-loader?inline=no-fallback!../workers/ZipWorker.mjs"; +import { + EditorView, + keymap, + highlightSpecialChars, + drawSelection, + rectangularSelection, + crosshairCursor +} from "@codemirror/view"; +import { + EditorState, + Compartment +} from "@codemirror/state"; +import { + defaultKeymap +} from "@codemirror/commands"; +import { + bracketMatching +} from "@codemirror/language"; +import { + search, + searchKeymap, + highlightSelectionMatches +} from "@codemirror/search"; + +import {statusBar} from "../utils/statusBar.mjs"; +import {htmlPlugin} from "../utils/htmlWidget.mjs"; +import {copyOverride} from "../utils/copyOverride.mjs"; +import {eolCodeToSeq, eolCodeToName, renderSpecialChar} from "../utils/editorUtils.mjs"; + + /** * Waiter to handle events related to the output */ @@ -25,10 +57,418 @@ class OutputWaiter { this.app = app; this.manager = manager; + this.outputTextEl = document.getElementById("output-text"); + // Object to handle output HTML state - used by htmlWidget extension + this.htmlOutput = { + html: "", + changed: false + }; + // Hold a copy of the currently displayed output so that we don't have to update it unnecessarily + this.currentOutputCache = null; + this.initEditor(); + this.outputs = {}; this.zipWorker = null; this.maxTabs = this.manager.tabs.calcMaxTabs(); this.tabTimeout = null; + this.eolState = 0; // 0 = unset, 1 = detected, 2 = manual + this.encodingState = 0; // 0 = unset, 1 = detected, 2 = manual + } + + /** + * Sets up the CodeMirror Editor + */ + initEditor() { + // Mutable extensions + this.outputEditorConf = { + eol: new Compartment, + lineWrapping: new Compartment, + drawSelection: new Compartment + }; + + const initialState = EditorState.create({ + doc: null, + extensions: [ + // Editor extensions + EditorState.readOnly.of(true), + highlightSpecialChars({ + render: renderSpecialChar, // Custom character renderer to handle special cases + addSpecialChars: /[\ue000-\uf8ff]/g // Add the Unicode Private Use Area which we use for some whitespace chars + }), + rectangularSelection(), + crosshairCursor(), + bracketMatching(), + highlightSelectionMatches(), + search({top: true}), + EditorState.allowMultipleSelections.of(true), + + // Custom extensions + statusBar({ + label: "Output", + timing: this.manager.timing, + tabNumGetter: function() { + return this.manager.tabs.getActiveTab("output"); + }.bind(this), + eolHandler: this.eolChange.bind(this), + chrEncHandler: this.chrEncChange.bind(this), + chrEncGetter: this.getChrEnc.bind(this), + getEncodingState: this.getEncodingState.bind(this), + getEOLState: this.getEOLState.bind(this), + htmlOutput: this.htmlOutput + }), + htmlPlugin(this.htmlOutput), + copyOverride(), + + // Mutable state + this.outputEditorConf.lineWrapping.of(EditorView.lineWrapping), + this.outputEditorConf.eol.of(EditorState.lineSeparator.of("\n")), + this.outputEditorConf.drawSelection.of(drawSelection()), + + // Keymap + keymap.of([ + ...defaultKeymap, + ...searchKeymap + ]), + + // Event listeners + EditorView.updateListener.of(e => { + if (e.selectionSet) + this.manager.highlighter.selectionChange("output", e); + if (e.docChanged || this.docChanging) { + this.docChanging = false; + this.toggleLoader(false); + } + }) + ] + }); + + if (this.outputEditorView) this.outputEditorView.destroy(); + this.outputEditorView = new EditorView({ + state: initialState, + parent: this.outputTextEl + }); + } + + /** + * Handler for EOL change events + * Sets the line separator + * @param {string} eol + * @param {boolean} [manual=false] + */ + async eolChange(eol, manual=false) { + const eolVal = eolCodeToSeq[eol]; + if (eolVal === undefined) return; + + this.eolState = manual ? 2 : this.eolState; + if (this.eolState < 2 && eolVal === this.getEOLSeq()) return; + + if (this.eolState === 1) { + // Alert + this.app.alert(`Output end of line separator has been detected and changed to ${eolCodeToName[eol]}`, 5000); + } + + const currentTabNum = this.manager.tabs.getActiveTab("output"); + if (currentTabNum >= 0) { + this.outputs[currentTabNum].eolSequence = eolVal; + } else { + throw new Error(`Cannot change output ${currentTabNum} EOL sequence to ${eolVal}`); + } + + // Update the EOL value + this.outputEditorView.dispatch({ + effects: this.outputEditorConf.eol.reconfigure(EditorState.lineSeparator.of(eolVal)) + }); + + // Reset the output so that lines are recalculated, preserving the old EOL values + await this.setOutput(this.currentOutputCache, true); + // Update the URL manually since we aren't firing a statechange event + this.app.updateURL(true); + } + + /** + * Getter for the output EOL sequence + * Prefer reading value from `this.outputs` since the editor may not have updated yet. + * @returns {string} + */ + getEOLSeq() { + const currentTabNum = this.manager.tabs.getActiveTab("output"); + if (currentTabNum < 0) { + return this.outputEditorConf.state?.lineBreak || "\n"; + } + return this.outputs[currentTabNum].eolSequence; + } + + /** + * Returns whether the output EOL sequence was set manually or has been detected automatically + * @returns {number} - 0 = unset, 1 = detected, 2 = manual + */ + getEOLState() { + return this.eolState; + } + + /** + * Handler for Chr Enc change events + * Sets the output character encoding + * @param {number} chrEncVal + * @param {boolean} [manual=false] + */ + async chrEncChange(chrEncVal, manual=false) { + if (typeof chrEncVal !== "number") return; + const currentEnc = this.getChrEnc(); + + const currentTabNum = this.manager.tabs.getActiveTab("output"); + if (currentTabNum >= 0) { + this.outputs[currentTabNum].encoding = chrEncVal; + } else { + throw new Error(`Cannot change output ${currentTabNum} chrEnc to ${chrEncVal}`); + } + + this.encodingState = manual ? 2 : this.encodingState; + + if (this.encodingState > 1) { + // Reset the output, forcing it to re-decode the data with the new character encoding + await this.setOutput(this.currentOutputCache, true); + // Update the URL manually since we aren't firing a statechange event + this.app.updateURL(true); + } else if (currentEnc !== chrEncVal) { + // Alert + this.app.alert(`Output character encoding has been detected and changed to ${CHR_ENC_SIMPLE_REVERSE_LOOKUP[chrEncVal] || "Raw Bytes"}`, 5000); + } + } + + /** + * Getter for the output character encoding + * @returns {number} + */ + getChrEnc() { + const currentTabNum = this.manager.tabs.getActiveTab("output"); + if (currentTabNum < 0) { + return 0; + } + return this.outputs[currentTabNum].encoding; + } + + /** + * Returns whether the output character encoding was set manually or has been detected automatically + * @returns {number} - 0 = unset, 1 = detected, 2 = manual + */ + getEncodingState() { + return this.encodingState; + } + + /** + * Sets word wrap on the output editor + * @param {boolean} wrap + */ + setWordWrap(wrap) { + this.outputEditorView.dispatch({ + effects: this.outputEditorConf.lineWrapping.reconfigure( + wrap ? EditorView.lineWrapping : [] + ) + }); + } + + /** + * Sets the value of the current output + * @param {string|ArrayBuffer} data + * @param {boolean} [force=false] + */ + async setOutput(data, force=false) { + // Don't do anything if the output hasn't changed + if (!force && data === this.currentOutputCache) { + this.manager.controls.hideStaleIndicator(); + this.toggleLoader(false); + return; + } + + this.currentOutputCache = data; + this.toggleLoader(true); + + // Remove class to #output-text to change display settings + this.outputTextEl.classList.remove("html-output"); + + // If data is an ArrayBuffer, convert to a string in the correct character encoding + const tabNum = this.manager.tabs.getActiveTab("output"); + this.manager.timing.recordTime("outputDecodingStart", tabNum); + if (data instanceof ArrayBuffer) { + await this.detectEncoding(data); + data = await this.bufferToStr(data); + } + this.manager.timing.recordTime("outputDecodingEnd", tabNum); + + // Turn drawSelection back on + this.outputEditorView.dispatch({ + effects: this.outputEditorConf.drawSelection.reconfigure( + drawSelection() + ) + }); + + // Ensure we're not exceeding the maximum line length + let wrap = this.app.options.wordWrap; + const lineLengthThreshold = 131072; // 128KB + if (data.length > lineLengthThreshold) { + const lines = data.split(this.getEOLSeq()); + const longest = lines.reduce((a, b) => + a > b.length ? a : b.length, 0 + ); + if (longest > lineLengthThreshold) { + // If we are exceeding the max line length, turn off word wrap + wrap = false; + } + } + + // If turning word wrap off, do it before we populate the editor for performance reasons + if (!wrap) this.setWordWrap(wrap); + + // Detect suitable EOL sequence + this.detectEOLSequence(data); + + // We use setTimeout here to delay the editor dispatch until the next event cycle, + // ensuring all async actions have completed before attempting to set the contents + // of the editor. This is mainly with the above call to setWordWrap() in mind. + setTimeout(() => { + this.docChanging = true; + // Insert data into editor, overwriting any previous contents + this.outputEditorView.dispatch({ + changes: { + from: 0, + to: this.outputEditorView.state.doc.length, + insert: data + } + }); + + // If turning word wrap on, do it after we populate the editor + if (wrap) + setTimeout(() => { + this.setWordWrap(wrap); + }); + }); + } + + /** + * Sets the value of the current output to a rendered HTML value + * @param {string} html + */ + async setHTMLOutput(html) { + this.htmlOutput.html = html; + this.htmlOutput.changed = true; + // This clears the text output, but also fires a View update which + // triggers the htmlWidget to render the HTML. We set the force flag + // to ensure the loader gets removed and HTML is rendered. + await this.setOutput("", true); + + // Turn off drawSelection + this.outputEditorView.dispatch({ + effects: this.outputEditorConf.drawSelection.reconfigure([]) + }); + + // Add class to #output-text to change display settings + this.outputTextEl.classList.add("html-output"); + + // Execute script sections + const outputHTML = document.getElementById("output-html"); + const scriptElements = outputHTML ? outputHTML.querySelectorAll("script") : []; + for (let i = 0; i < scriptElements.length; i++) { + try { + eval(scriptElements[i].innerHTML); // eslint-disable-line no-eval + } catch (err) { + log.error(err); + } + } + } + + /** + * Clears the HTML output + */ + clearHTMLOutput() { + this.htmlOutput.html = ""; + this.htmlOutput.changed = true; + // Fire a blank change to force the htmlWidget to update and remove any HTML + this.outputEditorView.dispatch({ + changes: { + from: 0, + insert: "" + } + }); + } + + /** + * Checks whether the EOL separator should be updated + * + * @param {string} data + */ + detectEOLSequence(data) { + // If EOL has been fixed, skip this. + if (this.eolState > 1) return; + // If data is too long, skip this. + if (data.length > 1000000) return; + + // Detect most likely EOL sequence + const eolCharCounts = { + "LF": data.count("\u000a"), + "VT": data.count("\u000b"), + "FF": data.count("\u000c"), + "CR": data.count("\u000d"), + "CRLF": data.count("\u000d\u000a"), + "NEL": data.count("\u0085"), + "LS": data.count("\u2028"), + "PS": data.count("\u2029") + }; + + // If all zero, leave alone + const total = Object.values(eolCharCounts).reduce((acc, curr) => { + return acc + curr; + }, 0); + if (total === 0) return; + + // Find most prevalent line ending sequence + const highest = Object.entries(eolCharCounts).reduce((acc, curr) => { + return curr[1] > acc[1] ? curr : acc; + }, ["LF", 0]); + let choice = highest[0]; + + // If CRLF not zero and more than half the highest alternative, choose CRLF + if ((eolCharCounts.CRLF * 2) > highest[1]) { + choice = "CRLF"; + } + + const eolVal = eolCodeToSeq[choice]; + if (eolVal === this.getEOLSeq()) return; + + // Setting automatically + this.eolState = 1; + this.eolChange(choice); + } + + /** + * Checks whether the character encoding should be updated. + * + * @param {ArrayBuffer} data + */ + async detectEncoding(data) { + // If encoding has been fixed, skip this. + if (this.encodingState > 1) return; + // If data is too long, skip this. + if (data.byteLength > 1000000) return; + + const enc = isUTF8(data); // 0 = not UTF8, 1 = ASCII, 2 = UTF8 + + switch (enc) { + case 0: // not UTF8 + // Set to Raw Bytes + this.encodingState = 1; + await this.chrEncChange(0, false); + break; + case 2: // UTF8 + // Set to UTF8 + this.encodingState = 1; + await this.chrEncChange(65001, false); + break; + case 1: // ASCII + default: + // Ignore + break; + } } /** @@ -38,7 +478,7 @@ class OutputWaiter { const numTabs = this.manager.tabs.calcMaxTabs(); if (numTabs !== this.maxTabs) { this.maxTabs = numTabs; - this.refreshTabs(this.manager.tabs.getActiveOutputTab(), "right"); + this.refreshTabs(this.manager.tabs.getActiveTab("output"), "right"); } } @@ -89,7 +529,9 @@ class OutputWaiter { error: null, status: "inactive", bakeId: -1, - progress: false + progress: false, + encoding: 0, + eolSequence: "\u000a" }; this.outputs[inputNum] = newOutput; @@ -116,7 +558,7 @@ class OutputWaiter { this.outputs[inputNum].data = data; - const tabItem = this.manager.tabs.getOutputTabItem(inputNum); + const tabItem = this.manager.tabs.getTabItem(inputNum, "output"); if (tabItem) tabItem.style.background = ""; if (set) this.set(inputNum); @@ -196,7 +638,7 @@ class OutputWaiter { this.outputs[inputNum].progress = progress; if (progress !== false) { - this.manager.tabs.updateOutputTabProgress(inputNum, progress, total); + this.manager.tabs.updateTabProgress(inputNum, progress, total, "output"); } } @@ -209,7 +651,7 @@ class OutputWaiter { removeOutput(inputNum) { if (!this.outputExists(inputNum)) return; - delete (this.outputs[inputNum]); + delete this.outputs[inputNum]; } /** @@ -218,8 +660,6 @@ class OutputWaiter { removeAllOutputs() { this.outputs = {}; - this.resetSwitch(); - const tabsList = document.getElementById("output-tabs"); const tabsListChildren = tabsList.children; @@ -231,25 +671,26 @@ class OutputWaiter { } /** - * Sets the output in the output textarea. + * Sets the output in the output pane. * * @param {number} inputNum */ async set(inputNum) { - if (inputNum !== this.manager.tabs.getActiveOutputTab() || + inputNum = parseInt(inputNum, 10); + if (inputNum !== this.manager.tabs.getActiveTab("output") || !this.outputExists(inputNum)) return; this.toggleLoader(true); return new Promise(async function(resolve, reject) { - const output = this.outputs[inputNum], - activeTab = this.manager.tabs.getActiveOutputTab(); - if (typeof inputNum !== "number") inputNum = parseInt(inputNum, 10); + const output = this.outputs[inputNum]; + this.manager.timing.recordTime("settingOutput", inputNum); - const outputText = document.getElementById("output-text"); - const outputHtml = document.getElementById("output-html"); - const outputFile = document.getElementById("output-file"); - const outputHighlighter = document.getElementById("output-highlighter"); - const inputHighlighter = document.getElementById("input-highlighter"); + // Update the EOL value + this.outputEditorView.dispatch({ + effects: this.outputEditorConf.eol.reconfigure( + EditorState.lineSeparator.of(output.eolSequence) + ) + }); // If pending or baking, show loader and status message // If error, style the tab and handle the error @@ -269,140 +710,55 @@ class OutputWaiter { this.manager.recipe.updateBreakpointIndicator(false); } - document.getElementById("show-file-overlay").style.display = "none"; - if (output.status === "pending" || output.status === "baking") { // show the loader and the status message if it's being shown // otherwise don't do anything document.querySelector("#output-loader .loading-msg").textContent = output.statusMessage; } else if (output.status === "error") { - // style the tab if it's being shown - this.toggleLoader(false); - outputText.style.display = "block"; - outputText.classList.remove("blur"); - outputHtml.style.display = "none"; - outputFile.style.display = "none"; - outputHighlighter.display = "none"; - inputHighlighter.display = "none"; + this.clearHTMLOutput(); if (output.error) { - outputText.value = output.error; + await this.setOutput(output.error); } else { - outputText.value = output.data.result; + await this.setOutput(output.data.result); } - outputHtml.innerHTML = ""; } else if (output.status === "baked" || output.status === "inactive") { document.querySelector("#output-loader .loading-msg").textContent = `Loading output ${inputNum}`; - this.closeFile(); - let scriptElements, lines, length; if (output.data === null) { - outputText.style.display = "block"; - outputHtml.style.display = "none"; - outputFile.style.display = "none"; - outputHighlighter.display = "block"; - inputHighlighter.display = "block"; - - outputText.value = ""; - outputHtml.innerHTML = ""; - - this.toggleLoader(false); + this.clearHTMLOutput(); + await this.setOutput(""); return; } switch (output.data.type) { case "html": - outputText.style.display = "none"; - outputHtml.style.display = "block"; - outputFile.style.display = "none"; - outputHighlighter.style.display = "none"; - inputHighlighter.style.display = "none"; - - outputText.value = ""; - outputHtml.innerHTML = output.data.result; - - // Execute script sections - scriptElements = outputHtml.querySelectorAll("script"); - for (let i = 0; i < scriptElements.length; i++) { - try { - eval(scriptElements[i].innerHTML); // eslint-disable-line no-eval - } catch (err) { - log.error(err); - } - } + await this.setHTMLOutput(output.data.result); break; case "ArrayBuffer": - outputText.style.display = "block"; - outputHtml.style.display = "none"; - outputHighlighter.display = "none"; - inputHighlighter.display = "none"; - - outputText.value = ""; - outputHtml.innerHTML = ""; - - length = output.data.result.byteLength; - this.setFile(await this.getDishBuffer(output.data.dish), activeTab); - break; case "string": default: - outputText.style.display = "block"; - outputHtml.style.display = "none"; - outputFile.style.display = "none"; - outputHighlighter.display = "block"; - inputHighlighter.display = "block"; - - outputText.value = Utils.printable(output.data.result, true); - outputHtml.innerHTML = ""; - - lines = output.data.result.count("\n") + 1; - length = output.data.result.length; + this.clearHTMLOutput(); + await this.setOutput(output.data.result); break; } - this.toggleLoader(false); + this.manager.timing.recordTime("complete", inputNum); - if (output.data.type === "html") { - const dishStr = await this.getDishStr(output.data.dish); - length = dishStr.length; - lines = dishStr.count("\n") + 1; - } + // Trigger an update so that the status bar recalculates timings + this.outputEditorView.dispatch({ + changes: { + from: 0, + to: 0 + } + }); - this.setOutputInfo(length, lines, output.data.duration); debounce(this.backgroundMagic, 50, "backgroundMagic", this, [])(); } }.bind(this)); } /** - * Shows file details - * - * @param {ArrayBuffer} buf - * @param {number} activeTab - */ - setFile(buf, activeTab) { - if (activeTab !== this.manager.tabs.getActiveOutputTab()) return; - // Display file overlay in output area with details - const fileOverlay = document.getElementById("output-file"), - fileSize = document.getElementById("output-file-size"), - outputText = document.getElementById("output-text"), - fileSlice = buf.slice(0, 4096); - - fileOverlay.style.display = "block"; - fileSize.textContent = buf.byteLength.toLocaleString() + " bytes"; - - outputText.classList.add("blur"); - outputText.value = Utils.printable(Utils.arrayBufferToStr(fileSlice)); - } - - /** - * Clears output file details - */ - closeFile() { - document.getElementById("output-file").style.display = "none"; - document.getElementById("output-text").classList.remove("blur"); - } - - /** - * Retrieves the dish as a string, returning the cached version if possible. + * Retrieves the dish as a string * * @param {Dish} dish * @returns {string} @@ -416,7 +772,7 @@ class OutputWaiter { } /** - * Retrieves the dish as an ArrayBuffer, returning the cached version if possible. + * Retrieves the dish as an ArrayBuffer * * @param {Dish} dish * @returns {ArrayBuffer} @@ -444,6 +800,23 @@ class OutputWaiter { }); } + /** + * Asks a worker to translate an ArrayBuffer into a certain character encoding + * + * @param {ArrrayBuffer} buffer + * @returns {string} + */ + async bufferToStr(buffer) { + const encoding = this.getChrEnc(); + + if (buffer.byteLength === 0) return ""; + return await new Promise(resolve => { + this.manager.worker.bufferToStr(buffer, encoding, r => { + resolve(r.value); + }); + }); + } + /** * Save bombe object then remove it from the DOM so that it does not cause performance issues. */ @@ -462,39 +835,41 @@ class OutputWaiter { * @param {boolean} value - If true, show the loader */ toggleLoader(value) { - clearTimeout(this.appendBombeTimeout); - clearTimeout(this.outputLoaderTimeout); - const outputLoader = document.getElementById("output-loader"), - outputElement = document.getElementById("output-text"), animation = document.getElementById("output-loader-animation"); if (value) { this.manager.controls.hideStaleIndicator(); + // Don't add the bombe if it's already there or scheduled to be loaded + if (animation.children.length === 0 && !this.appendBombeTimeout) { + // Start a timer to add the Bombe to the DOM just before we make it + // visible so that there is no stuttering + this.appendBombeTimeout = setTimeout(function() { + this.appendBombeTimeout = null; + animation.appendChild(this.bombeEl); + }.bind(this), 150); + } - // Don't add the bombe if it's already there! - if (animation.children.length > 0) return; + if (outputLoader.style.visibility !== "visible" && !this.outputLoaderTimeout) { + // Show the loading screen + this.outputLoaderTimeout = setTimeout(function() { + this.outputLoaderTimeout = null; + outputLoader.style.visibility = "visible"; + outputLoader.style.opacity = 1; + }, 200); + } + } else if (outputLoader.style.visibility !== "hidden" || this.appendBombeTimeout || this.outputLoaderTimeout) { + clearTimeout(this.appendBombeTimeout); + clearTimeout(this.outputLoaderTimeout); + this.appendBombeTimeout = null; + this.outputLoaderTimeout = null; - // Start a timer to add the Bombe to the DOM just before we make it - // visible so that there is no stuttering - this.appendBombeTimeout = setTimeout(function() { - animation.appendChild(this.bombeEl); - }.bind(this), 150); - - // Show the loading screen - this.outputLoaderTimeout = setTimeout(function() { - outputElement.disabled = true; - outputLoader.style.visibility = "visible"; - outputLoader.style.opacity = 1; - }, 200); - } else { // Remove the Bombe from the DOM to save resources this.outputLoaderTimeout = setTimeout(function () { - try { + this.outputLoaderTimeout = null; + if (animation.children.length > 0) animation.removeChild(this.bombeEl); - } catch (err) {} }.bind(this), 500); - outputElement.disabled = false; outputLoader.style.opacity = 0; outputLoader.style.visibility = "hidden"; } @@ -512,24 +887,33 @@ class OutputWaiter { * Handler for file download events. */ async downloadFile() { - const dish = this.getOutputDish(this.manager.tabs.getActiveOutputTab()); + const dish = this.getOutputDish(this.manager.tabs.getActiveTab("output")); if (dish === null) { this.app.alert("Could not find any output data to download. Has this output been baked?", 3000); return; } - const fileName = window.prompt("Please enter a filename: ", "download.dat"); + + const data = await dish.get(Dish.ARRAY_BUFFER); + let ext = ".dat"; + + // Detect file type automatically + const types = detectFileType(data); + if (types.length) { + ext = `.${types[0].extension.split(",", 1)[0]}`; + } + + const fileName = window.prompt("Please enter a filename: ", `download${ext}`); // Assume if the user clicks cancel they don't want to download if (fileName === null) return; - const data = await dish.get(Dish.ARRAY_BUFFER), - file = new File([data], fileName); - FileSaver.saveAs(file, fileName, false); + const file = new File([data], fileName); + FileSaver.saveAs(file, fileName, {autoBom: false}); } /** * Handler for save all click event - * Saves all outputs to a single archvie file + * Saves all outputs to a single archive file */ async saveAllClick() { const downloadButton = document.getElementById("save-all-to-file"); @@ -550,7 +934,6 @@ class OutputWaiter { } } - /** * Spawns a new ZipWorker and sends it the outputs so that they can * be zipped for download @@ -606,9 +989,16 @@ class OutputWaiter { log.debug("Creating ZipWorker"); this.zipWorker = new ZipWorker(); this.zipWorker.postMessage({ - outputs: this.outputs, - filename: fileName, - fileExtension: fileExt + action: "setLogLevel", + data: log.getLevel() + }); + this.zipWorker.postMessage({ + action: "zipFiles", + data: { + outputs: this.outputs, + filename: fileName, + fileExtension: fileExt + } }); this.zipWorker.addEventListener("message", this.handleZipWorkerMessage.bind(this)); } @@ -625,16 +1015,12 @@ class OutputWaiter { this.zipWorker = null; const downloadButton = document.getElementById("save-all-to-file"); - downloadButton.classList.remove("spin"); downloadButton.title = "Save all outputs to a zip file"; downloadButton.setAttribute("data-original-title", "Save all outputs to a zip file"); - downloadButton.firstElementChild.innerHTML = "archive"; - } - /** * Handle messages sent back by the ZipWorker */ @@ -652,7 +1038,7 @@ class OutputWaiter { } const file = new File([r.zippedFile], r.filename); - FileSaver.saveAs(file, r.filename, false); + FileSaver.saveAs(file, r.filename, {autoBom: false}); this.terminateZipWorker(); } @@ -667,9 +1053,9 @@ class OutputWaiter { const tabsWrapper = document.getElementById("output-tabs"); const numTabs = tabsWrapper.children.length; - if (!this.manager.tabs.getOutputTabItem(inputNum) && numTabs < this.maxTabs) { + if (!this.manager.tabs.getTabItem(inputNum, "output") && numTabs < this.maxTabs) { // Create a new tab element - const newTab = this.manager.tabs.createOutputTabElement(inputNum, changeTab); + const newTab = this.manager.tabs.createTabElement(inputNum, changeTab, "output"); tabsWrapper.appendChild(newTab); } else if (numTabs === this.maxTabs) { // Can't create a new tab @@ -691,14 +1077,11 @@ class OutputWaiter { */ changeTab(inputNum, changeInput = false) { if (!this.outputExists(inputNum)) return; - const currentNum = this.manager.tabs.getActiveOutputTab(); + const currentNum = this.manager.tabs.getActiveTab("output"); this.hideMagicButton(); - this.manager.highlighter.removeHighlights(); - getSelection().removeAllRanges(); - - if (!this.manager.tabs.changeOutputTab(inputNum)) { + if (!this.manager.tabs.changeTab(inputNum, "output")) { let direction = "right"; if (currentNum > inputNum) { direction = "left"; @@ -708,17 +1091,14 @@ class OutputWaiter { const tabsLeft = (newOutputs[0] !== this.getSmallestInputNum()); const tabsRight = (newOutputs[newOutputs.length - 1] !== this.getLargestInputNum()); - this.manager.tabs.refreshOutputTabs(newOutputs, inputNum, tabsLeft, tabsRight); + this.manager.tabs.refreshTabs(newOutputs, inputNum, tabsLeft, tabsRight, "output"); for (let i = 0; i < newOutputs.length; i++) { this.displayTabInfo(newOutputs[i]); } } - debounce(this.set, 50, "setOutput", this, [inputNum])(); - - document.getElementById("output-html").scroll(0, 0); - document.getElementById("output-text").scroll(0, 0); + this.set(inputNum); if (changeInput) { this.manager.input.changeTab(inputNum, false); @@ -732,6 +1112,7 @@ class OutputWaiter { */ changeTabClick(mouseEvent) { if (!mouseEvent.target) return; + const tabNum = mouseEvent.target.parentElement.getAttribute("inputNum"); if (tabNum) { this.changeTab(parseInt(tabNum, 10), this.app.options.syncTabs); @@ -801,7 +1182,7 @@ class OutputWaiter { * Handler for changing to the left tab */ changeTabLeft() { - const currentTab = this.manager.tabs.getActiveOutputTab(); + const currentTab = this.manager.tabs.getActiveTab("output"); this.changeTab(this.getPreviousInputNum(currentTab), this.app.options.syncTabs); } @@ -809,7 +1190,7 @@ class OutputWaiter { * Handler for changing to the right tab */ changeTabRight() { - const currentTab = this.manager.tabs.getActiveOutputTab(); + const currentTab = this.manager.tabs.getActiveTab("output"); this.changeTab(this.getNextInputNum(currentTab), this.app.options.syncTabs); } @@ -820,7 +1201,7 @@ class OutputWaiter { const min = this.getSmallestInputNum(), max = this.getLargestInputNum(); - let tabNum = window.prompt(`Enter tab number (${min} - ${max}):`, this.manager.tabs.getActiveOutputTab().toString()); + let tabNum = window.prompt(`Enter tab number (${min} - ${max}):`, this.manager.tabs.getActiveTab("output").toString()); if (tabNum === null) return; tabNum = parseInt(tabNum, 10); @@ -861,9 +1242,7 @@ class OutputWaiter { nums.push(newNum); } } - nums.sort(function(a, b) { - return a - b; - }); + nums.sort((a, b) => a - b); // Forces the sort function to treat a and b as numbers return nums; } @@ -939,7 +1318,7 @@ class OutputWaiter { removeTab(inputNum) { if (!this.outputExists(inputNum)) return; - const tabElement = this.manager.tabs.getOutputTabItem(inputNum); + const tabElement = this.manager.tabs.getTabItem(inputNum, "output"); this.removeOutput(inputNum); @@ -950,6 +1329,7 @@ class OutputWaiter { /** * Redraw the entire tab bar to remove any outdated tabs + * * @param {number} activeTab * @param {string} direction - Either "left" or "right" */ @@ -958,12 +1338,11 @@ class OutputWaiter { tabsLeft = (newNums[0] !== this.getSmallestInputNum() && newNums.length > 0), tabsRight = (newNums[newNums.length - 1] !== this.getLargestInputNum() && newNums.length > 0); - this.manager.tabs.refreshOutputTabs(newNums, activeTab, tabsLeft, tabsRight); + this.manager.tabs.refreshTabs(newNums, activeTab, tabsLeft, tabsRight, "output"); for (let i = 0; i < newNums.length; i++) { this.displayTabInfo(newNums[i]); } - } /** @@ -972,7 +1351,8 @@ class OutputWaiter { * @param {number} inputNum */ async displayTabInfo(inputNum) { - if (!this.outputExists(inputNum)) return; + // Don't display anything if there are no, or only one, tabs + if (!this.outputExists(inputNum) || Object.keys(this.outputs).length <= 1) return; const dish = this.getOutputDish(inputNum); let tabStr = ""; @@ -981,12 +1361,12 @@ class OutputWaiter { tabStr = await this.getDishTitle(this.getOutputDish(inputNum), 100); tabStr = tabStr.replace(/[\n\r]/g, ""); } - this.manager.tabs.updateOutputTabHeader(inputNum, tabStr); + this.manager.tabs.updateTabHeader(inputNum, tabStr, "output"); if (this.manager.worker.recipeConfig !== undefined) { - this.manager.tabs.updateOutputTabProgress(inputNum, this.outputs[inputNum].progress, this.manager.worker.recipeConfig.length); + this.manager.tabs.updateTabProgress(inputNum, this.outputs[inputNum]?.progress, this.manager.worker.recipeConfig.length, "output"); } - const tabItem = this.manager.tabs.getOutputTabItem(inputNum); + const tabItem = this.manager.tabs.getTabItem(inputNum, "output"); if (tabItem) { if (this.outputs[inputNum].status === "error") { tabItem.style.color = "#FF0000"; @@ -996,39 +1376,12 @@ class OutputWaiter { } } - /** - * Displays information about the output. - * - * @param {number} length - The length of the current output string - * @param {number} lines - The number of the lines in the current output string - * @param {number} duration - The length of time (ms) it took to generate the output - */ - setOutputInfo(length, lines, duration) { - if (!length) return; - let width = length.toString().length; - width = width < 4 ? 4 : width; - - const lengthStr = length.toString().padStart(width, " ").replace(/ /g, " "); - const timeStr = (duration.toString() + "ms").padStart(width, " ").replace(/ /g, " "); - - let msg = "time: " + timeStr + "
length: " + lengthStr; - - if (typeof lines === "number") { - const linesStr = lines.toString().padStart(width, " ").replace(/ /g, " "); - msg += "
lines: " + linesStr; - } - - document.getElementById("output-info").innerHTML = msg; - document.getElementById("input-selection-info").innerHTML = ""; - document.getElementById("output-selection-info").innerHTML = ""; - } - /** * Triggers the BackgroundWorker to attempt Magic on the current output. */ async backgroundMagic() { this.hideMagicButton(); - const dish = this.getOutputDish(this.manager.tabs.getActiveOutputTab()); + const dish = this.getOutputDish(this.manager.tabs.getActiveTab("output")); if (!this.app.options.autoMagic || dish === null) return; const buffer = await this.getDishBuffer(dish); const sample = buffer.slice(0, 1000) || ""; @@ -1105,92 +1458,6 @@ class OutputWaiter { magicButton.setAttribute("data-original-title", "Magic!"); } - - /** - * Handler for file slice display events. - */ - async displayFileSlice() { - document.querySelector("#output-loader .loading-msg").textContent = "Loading file slice..."; - this.toggleLoader(true); - const outputText = document.getElementById("output-text"), - outputHtml = document.getElementById("output-html"), - outputFile = document.getElementById("output-file"), - outputHighlighter = document.getElementById("output-highlighter"), - inputHighlighter = document.getElementById("input-highlighter"), - showFileOverlay = document.getElementById("show-file-overlay"), - sliceFromEl = document.getElementById("output-file-slice-from"), - sliceToEl = document.getElementById("output-file-slice-to"), - sliceFrom = parseInt(sliceFromEl.value, 10) * 1024, - sliceTo = parseInt(sliceToEl.value, 10) * 1024, - output = this.outputs[this.manager.tabs.getActiveOutputTab()].data; - - let str; - if (output.type === "ArrayBuffer") { - str = Utils.arrayBufferToStr(output.result.slice(sliceFrom, sliceTo)); - } else { - str = Utils.arrayBufferToStr(await this.getDishBuffer(output.dish).slice(sliceFrom, sliceTo)); - } - - outputText.classList.remove("blur"); - showFileOverlay.style.display = "block"; - outputText.value = Utils.printable(str, true); - - outputText.style.display = "block"; - outputHtml.style.display = "none"; - outputFile.style.display = "none"; - outputHighlighter.display = "block"; - inputHighlighter.display = "block"; - - this.toggleLoader(false); - } - - /** - * Handler for showing an entire file at user's discretion (even if it's way too big) - */ - async showAllFile() { - document.querySelector("#output-loader .loading-msg").textContent = "Loading entire file at user instruction. This may cause a crash..."; - this.toggleLoader(true); - const outputText = document.getElementById("output-text"), - outputHtml = document.getElementById("output-html"), - outputFile = document.getElementById("output-file"), - outputHighlighter = document.getElementById("output-highlighter"), - inputHighlighter = document.getElementById("input-highlighter"), - showFileOverlay = document.getElementById("show-file-overlay"), - output = this.outputs[this.manager.tabs.getActiveOutputTab()].data; - - let str; - if (output.type === "ArrayBuffer") { - str = Utils.arrayBufferToStr(output.result); - } else { - str = Utils.arrayBufferToStr(await this.getDishBuffer(output.dish)); - } - - outputText.classList.remove("blur"); - showFileOverlay.style.display = "none"; - outputText.value = Utils.printable(str, true); - - outputText.style.display = "block"; - outputHtml.style.display = "none"; - outputFile.style.display = "none"; - outputHighlighter.display = "block"; - inputHighlighter.display = "block"; - - this.toggleLoader(false); - } - - /** - * Handler for show file overlay events - * - * @param {Event} e - */ - showFileOverlayClick(e) { - const showFileOverlay = e.target; - - document.getElementById("output-text").classList.add("blur"); - showFileOverlay.style.display = "none"; - this.set(this.manager.tabs.getActiveOutputTab()); - } - /** * Handler for extract file events. * @@ -1214,58 +1481,20 @@ class OutputWaiter { * Copies the output to the clipboard */ async copyClick() { - const dish = this.getOutputDish(this.manager.tabs.getActiveOutputTab()); + const dish = this.getOutputDish(this.manager.tabs.getActiveTab("output")); if (dish === null) { this.app.alert("Could not find data to copy. Has this output been baked yet?", 3000); return; } - const output = await dish.get(Dish.STRING); + const output = await this.getDishStr(dish); + const self = this; - // Create invisible textarea to populate with the raw dish string (not the printable version that - // contains dots instead of the actual bytes) - const textarea = document.createElement("textarea"); - textarea.style.position = "fixed"; - textarea.style.top = 0; - textarea.style.left = 0; - textarea.style.width = 0; - textarea.style.height = 0; - textarea.style.border = "none"; - - textarea.value = output; - document.body.appendChild(textarea); - - let success = false; - try { - textarea.select(); - success = output && document.execCommand("copy"); - } catch (err) { - success = false; - } - - if (success) { - this.app.alert("Copied raw output successfully.", 2000); - } else { - this.app.alert("Sorry, the output could not be copied.", 3000); - } - - // Clean up - document.body.removeChild(textarea); - } - - /** - * Returns true if the output contains carriage returns - * - * @returns {boolean} - */ - async containsCR() { - const dish = this.getOutputDish(this.manager.tabs.getActiveOutputTab()); - if (dish === null) return; - - if (dish.type === Dish.STRING) { - const data = await dish.get(Dish.STRING); - return data.indexOf("\r") >= 0; - } + navigator.clipboard.writeText(output).then(function() { + self.app.alert("Copied raw output successfully.", 2000); + }, function(err) { + self.app.alert("Sorry, the output could not be copied.", 3000); + }); } /** @@ -1273,93 +1502,25 @@ class OutputWaiter { * Moves the current output into the input textarea. */ async switchClick() { - const activeTab = this.manager.tabs.getActiveOutputTab(); - const transferable = []; - + const activeTab = this.manager.tabs.getActiveTab("output"); const switchButton = document.getElementById("switch"); + switchButton.classList.add("spin"); switchButton.disabled = true; switchButton.firstElementChild.innerHTML = "autorenew"; $(switchButton).tooltip("hide"); - let active = await this.getDishBuffer(this.getOutputDish(activeTab)); + const activeData = await this.getDishBuffer(this.getOutputDish(activeTab)); - if (!this.outputExists(activeTab)) { - this.resetSwitchButton(); - return; + if (this.outputExists(activeTab)) { + this.manager.input.set(activeTab, { + type: "userinput", + buffer: activeData, + encoding: this.outputs[activeTab].encoding, + eolSequence: this.outputs[activeTab].eolSequence + }); } - if (this.outputs[activeTab].data.type === "string" && - active.byteLength <= this.app.options.ioDisplayThreshold * 1024) { - const dishString = await this.getDishStr(this.getOutputDish(activeTab)); - if (!await this.manager.input.preserveCarriageReturns(dishString)) { - active = dishString; - } - } else { - transferable.push(active); - } - - this.manager.input.inputWorker.postMessage({ - action: "inputSwitch", - data: { - inputNum: activeTab, - outputData: active - } - }, transferable); - } - - /** - * Handler for when the inputWorker has switched the inputs. - * Stores the old input - * - * @param {object} switchData - * @param {number} switchData.inputNum - * @param {string | object} switchData.data - * @param {ArrayBuffer} switchData.data.fileBuffer - * @param {number} switchData.data.size - * @param {string} switchData.data.type - * @param {string} switchData.data.name - */ - inputSwitch(switchData) { - this.switchOrigData = switchData; - document.getElementById("undo-switch").disabled = false; - - this.resetSwitchButton(); - - } - - /** - * Handler for undo switch click events. - * Removes the output from the input and replaces the input that was removed. - */ - undoSwitchClick() { - this.manager.input.updateInputObj(this.switchOrigData.inputNum, this.switchOrigData.data); - - this.manager.input.fileLoaded(this.switchOrigData.inputNum); - - this.resetSwitch(); - } - - /** - * Removes the switch data and resets the switch buttons - */ - resetSwitch() { - if (this.switchOrigData !== undefined) { - delete this.switchOrigData; - } - - const undoSwitch = document.getElementById("undo-switch"); - undoSwitch.disabled = true; - $(undoSwitch).tooltip("hide"); - - this.resetSwitchButton(); - } - - /** - * Resets the switch button to its usual state - */ - resetSwitchButton() { - const switchButton = document.getElementById("switch"); switchButton.classList.remove("spin"); switchButton.disabled = false; switchButton.firstElementChild.innerHTML = "open_in_browser"; @@ -1380,10 +1541,12 @@ class OutputWaiter { this.app.ioSplitter.collapse(0); $(el).attr("data-original-title", "Restore output pane"); + $(el).attr("aria-label", "Restore output pane"); el.querySelector("i").innerHTML = "fullscreen_exit"; } else { document.body.classList.remove("output-maximised"); $(el).attr("data-original-title", "Maximise output pane"); + $(el).attr("aria-label", "Maximise output pane"); el.querySelector("i").innerHTML = "fullscreen"; this.app.initialiseSplitter(false); this.app.resetLayout(); @@ -1509,6 +1672,18 @@ class OutputWaiter { $("#output-tab-modal").modal("hide"); this.changeTab(inputNum, this.app.options.syncTabs); } + + + /** + * Sets the console log level in the workers. + */ + setLogLevel() { + if (!this.zipWorker) return; + this.zipWorker.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); + } } export default OutputWaiter; diff --git a/src/web/waiters/RecipeWaiter.mjs b/src/web/waiters/RecipeWaiter.mjs index f4107e66..4272ef3b 100755 --- a/src/web/waiters/RecipeWaiter.mjs +++ b/src/web/waiters/RecipeWaiter.mjs @@ -7,6 +7,8 @@ import HTMLOperation from "../HTMLOperation.mjs"; import Sortable from "sortablejs"; import Utils from "../../core/Utils.mjs"; +import {escapeControlChars} from "../utils/editorUtils.mjs"; +import DOMPurify from "dompurify"; /** @@ -132,7 +134,7 @@ class RecipeWaiter { // Reinitialise the popover on the original element in the ops list because for some reason it // gets destroyed and recreated. If the clone isn't in the ops list, we use the original item instead. let enableOpsElement; - if (evt.clone.parentNode && evt.clone.parentNode.classList.contains("op-list")) { + if (evt.clone?.parentNode?.classList?.contains("op-list")) { enableOpsElement = evt.clone; } else { enableOpsElement = evt.item; @@ -162,13 +164,13 @@ class RecipeWaiter { e.stopPropagation(); e.preventDefault(); - if (e.target.className && e.target.className.indexOf("category-title") > -1) { + if (e.target?.className?.indexOf("category-title") > -1) { // Hovering over the a e.target.classList.add("favourites-hover"); - } else if (e.target.parentNode.className && e.target.parentNode.className.indexOf("category-title") > -1) { + } else if (e.target?.parentNode?.className?.indexOf("category-title") > -1) { // Hovering over the Edit button e.target.parentNode.classList.add("favourites-hover"); - } else if (e.target.parentNode.parentNode.className && e.target.parentNode.parentNode.className.indexOf("category-title") > -1) { + } else if (e.target?.parentNode?.parentNode?.className?.indexOf("category-title") > -1) { // Hovering over the image on the Edit button e.target.parentNode.parentNode.classList.add("favourites-hover"); } @@ -210,10 +212,49 @@ class RecipeWaiter { * @fires Manager#statechange */ ingChange(e) { - if (e && e.target && e.target.classList.contains("no-state-change")) return; + if (e && e?.target?.classList?.contains("no-state-change")) return; window.dispatchEvent(this.manager.statechange); } + /** + * Handler for hide-args click events. + * Updates the icon status. + * + * @fires Manager#statechange + * @param {event} e + */ + hideArgsClick(e) { + const icon = e.target; + + if (icon.getAttribute("hide-args") === "false") { + icon.setAttribute("hide-args", "true"); + icon.innerText = "keyboard_arrow_down"; + icon.classList.add("hide-args-selected"); + icon.parentNode.previousElementSibling.style.display = "none"; + } else { + icon.setAttribute("hide-args", "false"); + icon.innerText = "keyboard_arrow_up"; + icon.classList.remove("hide-args-selected"); + icon.parentNode.previousElementSibling.style.display = "grid"; + } + + const icons = Array.from(document.getElementsByClassName("hide-args-icon")); + if (icons.length > 1) { + // Check if ALL the icons are hidden/shown + const uniqueIcons = icons.map(function(item) { + return item.getAttribute("hide-args"); + }).unique(); + + const controlsIconStatus = document.getElementById("hide-icon").getAttribute("hide-args"); + + // If all icons are in the same state and the global icon isn't, fix it + if (uniqueIcons.length === 1 && icon.getAttribute("hide-args") !== controlsIconStatus) { + this.manager.controls.hideRecipeArgsClick(); + } + } + + window.dispatchEvent(this.manager.statechange); + } /** * Handler for disable click events. @@ -376,6 +417,8 @@ class RecipeWaiter { el.classList.add("flow-control-op"); } + $(el).find("[data-toggle='tooltip']").tooltip(); + // Disable auto-bake if this is a manual op if (op.manualBake && this.app.autoBake_) { this.manager.controls.setAutoBake(false); @@ -395,12 +438,12 @@ class RecipeWaiter { const item = document.createElement("li"); item.classList.add("operation"); - item.innerHTML = name; + const clean = DOMPurify.sanitize(name); + item.innerHTML = clean; + this.buildRecipeOperation(item); document.getElementById("rec-list").appendChild(item); - $(item).find("[data-toggle='tooltip']").tooltip(); - item.dispatchEvent(this.manager.operationadd); return item; } @@ -568,7 +611,7 @@ class RecipeWaiter { const registerList = []; for (let i = 0; i < registers.length; i++) { - registerList.push(`$R${numPrevRegisters + i} = ${Utils.escapeHtml(Utils.truncate(Utils.printable(registers[i]), 100))}`); + registerList.push(`$R${numPrevRegisters + i} = ${escapeControlChars(Utils.escapeHtml(Utils.truncate(registers[i], 100)))}`); } const registerListEl = `
+ ${this.hidden ? "❰" : "❱"}
+
+ File details
+ +| Name: | ++ ${Utils.escapeHtml(this.fileDetails?.name)} + | +
| Size: | ++ ${Utils.escapeHtml(this.fileDetails?.size)} bytes + | +
| Type: | ++ ${Utils.escapeHtml(this.fileDetails?.type)} + | +
| Loaded: | ++ ${this.status === "error" ? "Error" : this.progress + "%"} + | +
${eolName}`); + button.setAttribute("data-original-title", `End of line sequence:
${eolName}`); + this.eolVal = state.lineBreak; + } + + + /** + * Sets the current character encoding of the document + */ + updateCharEnc() { + const chrEncVal = this.chrEncGetter(); + if (this.getEncodingState() < 2 && chrEncVal === this.chrEncVal) return; + + let name = CHR_ENC_SIMPLE_REVERSE_LOOKUP[chrEncVal] ? CHR_ENC_SIMPLE_REVERSE_LOOKUP[chrEncVal] : "Raw Bytes"; + + const val = this.dom.querySelector(".chr-enc-value"); + const button = val.closest(".cm-status-bar-select-btn"); + + switch (this.getEncodingState()) { + case 1: // Detected + val.classList.add("font-italic"); + name += " (detected)"; + // Pulse + val.classList.add("pulse"); + setTimeout(() => { + val.classList.remove("pulse"); + }, 2000); + break; + case 0: // Unset + case 2: // Manually set + default: + val.classList.remove("font-italic"); + break; + } + + val.textContent = name; + button.setAttribute("title", `${this.label} character encoding:
${name}`); + button.setAttribute("data-original-title", `${this.label} character encoding:
${name}`); + this.chrEncVal = chrEncVal; + } + + /** + * Sets the latest timing info + */ + updateTiming() { + if (!this.timing) return; + + const bakingTime = this.dom.querySelector(".baking-time-value"); + const bakingTimeInfo = this.dom.querySelector(".baking-time-info"); + + if (this.label === "Output" && this.timing) { + bakingTimeInfo.style.display = "inline-block"; + bakingTime.textContent = this.timing.duration(this.tabNumGetter()); + + const info = this.timing.printStages(this.tabNumGetter()).replace(/\n/g, "
"); + bakingTimeInfo.setAttribute("data-original-title", info); + } else { + bakingTimeInfo.style.display = "none"; + } + } + + /** + * Updates the sizing of elements that need to fit correctly + * @param {EditorView} view + */ + updateSizing(view) { + const viewHeight = view.contentDOM.parentNode.clientHeight; + this.dom.querySelectorAll(".cm-status-bar-select-scroll").forEach( + el => { + el.style.maxHeight = (viewHeight - 50) + "px"; + } + ); + } + + /** + * Checks whether there is HTML output requiring some widgets to be disabled + */ + monitorHTMLOutput() { + if (!this.htmlOutput?.changed) return; + + if (this.htmlOutput?.html === "") { + // Enable all controls + this.dom.querySelectorAll(".disabled").forEach(el => { + el.classList.remove("disabled"); + }); + } else { + // Disable chrenc, length, selection etc. + this.dom.querySelectorAll(".cm-status-bar-select-btn").forEach(el => { + el.classList.add("disabled"); + }); + + this.dom.querySelector(".stats-length-value").parentNode.classList.add("disabled"); + this.dom.querySelector(".stats-lines-value").parentNode.classList.add("disabled"); + this.dom.querySelector(".sel-info").classList.add("disabled"); + this.dom.querySelector(".cur-offset-info").classList.add("disabled"); + } + } + + /** + * Builds the Left-hand-side widgets + * @returns {string} + */ + constructLHS() { + return ` + + abc + + + + sort + + + + + highlight_alt + \u279E + ( selected) + + + location_on + + `; + } + + /** + * Builds the Right-hand-side widgets + * Event listener set up in Manager + * + * @returns {string} + */ + constructRHS() { + const chrEncOptions = Object.keys(CHR_ENC_SIMPLE_LOOKUP).map(name => + `${name}` + ).join(""); + + let chrEncHelpText = "", + eolHelpText = ""; + if (this.label === "Input") { + chrEncHelpText = "The input character encoding defines how the input text is encoded into bytes which are then processed by the Recipe.
The 'Raw bytes' option attempts to treat the input as individual bytes in the range 0-255. If it detects any characters with Unicode values above 255, it will treat the entire input as UTF-8. 'Raw bytes' is usually the best option if you are inputting binary data, such as a file."; + eolHelpText = "The End of Line Sequence defines which bytes are considered EOL terminators. Pressing the return key will enter this value into the input and create a new line.
Changing the EOL sequence will not modify any existing data in the input but may change how previously entered line breaks are displayed. Lines added while a different EOL terminator was set may not now result in a new line, but may be displayed as control characters instead."; + } else { + chrEncHelpText = "The output character encoding defines how the output bytes are decoded into text which can be displayed to you.
The 'Raw bytes' option treats the output data as individual bytes in the range 0-255."; + eolHelpText = "The End of Line Sequence defines which bytes are considered EOL terminators.
Changing this value will not modify the value of the output, but may change how certain bytes are displayed and whether they result in a new line being created."; + } + + return ` + + + + + `; + } + +} + +const elementsWithListeners = {}; + +/** + * Hides the provided element when a click is made outside of it + * @param {Element} element + * @param {Event} instantiatingEvent + */ +function hideOnClickOutside(element, instantiatingEvent) { + /** + * Handler for document click events + * Closes element if click is outside it. + * @param {Event} event + */ + const outsideClickListener = event => { + // Don't trigger if we're clicking inside the element, or if the element + // is not visible, or if this is the same click event that opened it. + if (!element.contains(event.target) && + event.timeStamp !== instantiatingEvent.timeStamp) { + hideElement(element); + } + }; + + if (!Object.prototype.hasOwnProperty.call(elementsWithListeners, element)) { + elementsWithListeners[element] = outsideClickListener; + document.addEventListener("click", elementsWithListeners[element], false); + } +} + +/** + * Hides the specified element and removes the click listener for it + * @param {Element} element + */ +function hideElement(element) { + element.classList.remove("show"); + document.removeEventListener("click", elementsWithListeners[element], false); + delete elementsWithListeners[element]; +} + + +/** + * A panel constructor factory building a panel that re-counts the stats every time the document changes. + * @param {Object} opts + * @returns {Function
end: " + endStr + "
length: " + lenStr; - } - - - /** - * Removes highlighting and selection information. - */ - removeHighlights() { - document.getElementById("input-highlighter").innerHTML = ""; - document.getElementById("output-highlighter").innerHTML = ""; - document.getElementById("input-selection-info").innerHTML = ""; - document.getElementById("output-selection-info").innerHTML = ""; - } - - - /** - * Highlights the given offsets in the output. + * Highlights the given offsets in the input or output. * We will only highlight if: * - input hasn't changed since last bake * - last bake was a full bake * - all operations in the recipe support highlighting * - * @param {Object} pos - The position object for the highlight. - * @param {number} pos.start - The start offset. - * @param {number} pos.end - The end offset. + * @param {string} io + * @param {ViewUpdate} e */ - highlightOutput(pos) { + selectionChange(io, e) { + // Confirm we are not currently baking if (!this.app.autoBake_ || this.app.baking) return false; - this.manager.worker.highlight(this.app.getRecipeConfig(), "forward", pos); + + // Confirm this was a user-generated event to prevent looping + // from setting the selection in this class + if (!e.transactions[0].isUserEvent("select")) return false; + + this.currentSelectionRanges = []; + + // Confirm some non-empty ranges are set + const selectionRanges = e.state.selection.ranges; + + // Adjust offsets based on the width of the character set + const inputCharacterWidth = chrEncWidth(this.manager.input.getChrEnc()); + const outputCharacterWidth = chrEncWidth(this.manager.output.getChrEnc()); + let ratio = 1; + if (inputCharacterWidth !== outputCharacterWidth && + inputCharacterWidth !== 0 && outputCharacterWidth !== 0) { + ratio = io === "input" ? + inputCharacterWidth / outputCharacterWidth : + outputCharacterWidth / inputCharacterWidth; + } + + // Loop through ranges and send request for output offsets for each one + const direction = io === "input" ? "forward" : "reverse"; + for (const range of selectionRanges) { + const pos = [{ + start: Math.floor(range.from * ratio), + end: Math.floor(range.to * ratio) + }]; + this.manager.worker.highlight(this.app.getRecipeConfig(), direction, pos); + } } - - /** - * Highlights the given offsets in the input. - * We will only highlight if: - * - input hasn't changed since last bake - * - last bake was a full bake - * - all operations in the recipe support highlighting - * - * @param {Object} pos - The position object for the highlight. - * @param {number} pos.start - The start offset. - * @param {number} pos.end - The end offset. - */ - highlightInput(pos) { - if (!this.app.autoBake_ || this.app.baking) return false; - this.manager.worker.highlight(this.app.getRecipeConfig(), "reverse", pos); - } - - /** * Displays highlight offsets sent back from the Chef. * - * @param {Object} pos - The position object for the highlight. + * @param {Object[]} pos - The position object for the highlight. * @param {number} pos.start - The start offset. * @param {number} pos.end - The end offset. * @param {string} direction */ displayHighlights(pos, direction) { if (!pos) return; - - if (this.manager.tabs.getActiveInputTab() !== this.manager.tabs.getActiveOutputTab()) return; + if (this.manager.tabs.getActiveTab("input") !== this.manager.tabs.getActiveTab("output")) return; const io = direction === "forward" ? "output" : "input"; - - document.getElementById(io + "-selection-info").innerHTML = this.selectionInfo(pos[0].start, pos[0].end); - this.highlight( - document.getElementById(io + "-text"), - document.getElementById(io + "-highlighter"), - pos); + this.highlight(io, pos); } - /** - * Adds the relevant HTML to the specified highlight element such that highlighting appears - * underneath the correct offset. + * Sends selection updates to the relevant EditorView. * - * @param {element} textarea - The input or output textarea. - * @param {element} highlighter - The input or output highlighter element. - * @param {Object} pos - The position object for the highlight. - * @param {number} pos.start - The start offset. - * @param {number} pos.end - The end offset. + * @param {string} io - The input or output + * @param {Object[]} ranges - An array of position objects to highlight + * @param {number} ranges.start - The start offset + * @param {number} ranges.end - The end offset */ - async highlight(textarea, highlighter, pos) { + async highlight(io, ranges) { if (!this.app.options.showHighlighter) return false; if (!this.app.options.attemptHighlight) return false; + if (!ranges || !ranges.length) return false; - // Check if there is a carriage return in the output dish as this will not - // be displayed by the HTML textarea and will mess up highlighting offsets. - if (await this.manager.output.containsCR()) return false; + const view = io === "input" ? + this.manager.input.inputEditorView : + this.manager.output.outputEditorView; - const startPlaceholder = "[startHighlight]"; - const startPlaceholderRegex = /\[startHighlight\]/g; - const endPlaceholder = "[endHighlight]"; - const endPlaceholderRegex = /\[endHighlight\]/g; - let text = textarea.value; + // Add new SelectionRanges to existing ones + for (const range of ranges) { + if (typeof range.start !== "number" || + typeof range.end !== "number") + continue; + const selection = range.end <= range.start ? + EditorSelection.cursor(range.start) : + EditorSelection.range(range.start, range.end); - // Put placeholders in position - // If there's only one value, select that - // If there are multiple, ignore the first one and select all others - if (pos.length === 1) { - if (pos[0].end < pos[0].start) return; - text = text.slice(0, pos[0].start) + - startPlaceholder + text.slice(pos[0].start, pos[0].end) + endPlaceholder + - text.slice(pos[0].end, text.length); - } else { - // O(n^2) - Can anyone improve this without overwriting placeholders? - let result = "", - endPlaced = true; - - for (let i = 0; i < text.length; i++) { - for (let j = 1; j < pos.length; j++) { - if (pos[j].end < pos[j].start) continue; - if (pos[j].start === i) { - result += startPlaceholder; - endPlaced = false; - } - if (pos[j].end === i) { - result += endPlaceholder; - endPlaced = true; - } - } - result += text[i]; - } - if (!endPlaced) result += endPlaceholder; - text = result; + this.currentSelectionRanges.push(selection); } - const cssClass = "hl1"; - - // Remove HTML tags - text = text - .replace(/&/g, "&") - .replace(//g, ">") - .replace(/\n/g, " ") - // Convert placeholders to tags - .replace(startPlaceholderRegex, "") - .replace(endPlaceholderRegex, "") + " "; - - // Adjust width to allow for scrollbars - highlighter.style.width = textarea.clientWidth + "px"; - highlighter.innerHTML = text; - highlighter.scrollTop = textarea.scrollTop; - highlighter.scrollLeft = textarea.scrollLeft; + // Set selection + if (this.currentSelectionRanges.length) { + try { + view.dispatch({ + selection: EditorSelection.create(this.currentSelectionRanges), + scrollIntoView: true + }); + } catch (err) { + // Ignore Range Errors + if (!err.toString().startsWith("RangeError")) { + log.error(err); + } + } + } } } diff --git a/src/web/waiters/InputWaiter.mjs b/src/web/waiters/InputWaiter.mjs index b421d8d8..94663a0b 100644 --- a/src/web/waiters/InputWaiter.mjs +++ b/src/web/waiters/InputWaiter.mjs @@ -7,9 +7,42 @@ import LoaderWorker from "worker-loader?inline=no-fallback!../workers/LoaderWorker.js"; import InputWorker from "worker-loader?inline=no-fallback!../workers/InputWorker.mjs"; -import Utils, { debounce } from "../../core/Utils.mjs"; -import { toBase64 } from "../../core/lib/Base64.mjs"; -import { isImage } from "../../core/lib/FileType.mjs"; +import Utils, {debounce} from "../../core/Utils.mjs"; +import {toBase64} from "../../core/lib/Base64.mjs"; +import cptable from "codepage"; + +import { + EditorView, + keymap, + highlightSpecialChars, + drawSelection, + rectangularSelection, + crosshairCursor, + dropCursor +} from "@codemirror/view"; +import { + EditorState, + Compartment +} from "@codemirror/state"; +import { + defaultKeymap, + insertTab, + insertNewline, + history, + historyKeymap +} from "@codemirror/commands"; +import { + bracketMatching +} from "@codemirror/language"; +import { + search, + searchKeymap, + highlightSelectionMatches +} from "@codemirror/search"; + +import {statusBar} from "../utils/statusBar.mjs"; +import {fileDetailsPanel} from "../utils/fileDetails.mjs"; +import {eolCodeToSeq, eolCodeToName, renderSpecialChar} from "../utils/editorUtils.mjs"; /** @@ -27,23 +60,11 @@ class InputWaiter { this.app = app; this.manager = manager; - // Define keys that don't change the input so we don't have to autobake when they are pressed - this.badKeys = [ - 16, // Shift - 17, // Ctrl - 18, // Alt - 19, // Pause - 20, // Caps - 27, // Esc - 33, 34, 35, 36, // PgUp, PgDn, End, Home - 37, 38, 39, 40, // Directional - 44, // PrntScrn - 91, 92, // Win - 93, // Context - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, // F1-12 - 144, // Num - 145, // Scroll - ]; + this.inputTextEl = document.getElementById("input-text"); + this.inputChrEnc = 0; + this.eolState = 0; // 0 = unset, 1 = detected, 2 = manual + this.encodingState = 0; // 0 = unset, 1 = detected, 2 = manual + this.initEditor(); this.inputWorker = null; this.loaderWorkers = []; @@ -51,6 +72,7 @@ class InputWaiter { this.maxTabs = this.manager.tabs.calcMaxTabs(); this.callbacks = {}; this.callbackID = 0; + this.fileDetails = {}; this.maxWorkers = 1; if (navigator.hardwareConcurrency !== undefined && @@ -61,6 +83,251 @@ class InputWaiter { } } + /** + * Sets up the CodeMirror Editor + */ + initEditor() { + // Mutable extensions + this.inputEditorConf = { + eol: new Compartment, + lineWrapping: new Compartment, + fileDetailsPanel: new Compartment + }; + + const self = this; + const initialState = EditorState.create({ + doc: null, + extensions: [ + // Editor extensions + history(), + highlightSpecialChars({ + render: renderSpecialChar // Custom character renderer to handle special cases + }), + drawSelection(), + rectangularSelection(), + crosshairCursor(), + dropCursor(), + bracketMatching(), + highlightSelectionMatches(), + search({top: true}), + EditorState.allowMultipleSelections.of(true), + + // Custom extensions + statusBar({ + label: "Input", + eolHandler: this.eolChange.bind(this), + chrEncHandler: this.chrEncChange.bind(this), + chrEncGetter: this.getChrEnc.bind(this), + getEncodingState: this.getEncodingState.bind(this), + getEOLState: this.getEOLState.bind(this) + }), + + // Mutable state + this.inputEditorConf.fileDetailsPanel.of([]), + this.inputEditorConf.lineWrapping.of(EditorView.lineWrapping), + this.inputEditorConf.eol.of(EditorState.lineSeparator.of("\n")), + + // Keymap + keymap.of([ + // Explicitly insert a tab rather than indenting the line + { key: "Tab", run: insertTab }, + // Explicitly insert a new line (using the current EOL char) rather + // than messing around with indenting, which does not respect EOL chars + { key: "Enter", run: insertNewline }, + ...historyKeymap, + ...defaultKeymap, + ...searchKeymap + ]), + + // Event listeners + EditorView.updateListener.of(e => { + if (e.selectionSet) + this.manager.highlighter.selectionChange("input", e); + if (e.docChanged && !this.silentInputChange) + this.inputChange(e); + this.silentInputChange = false; + }), + + // Event handlers + EditorView.domEventHandlers({ + paste(event, view) { + const clipboardData = event.clipboardData; + const items = clipboardData.items; + let files = []; + for (let i = 0; i < items.length; i++) { + const item = items[i]; + if (item.kind === "string") { + // If there are any string items they should be preferred over + // files. + files = []; + break; + } else if (item.kind === "file") { + files.push(item.getAsFile()); + } + } + if (files.length > 0) { + // Prevent the default paste behavior, afterPaste will load the files instead + event.preventDefault(); + } + setTimeout(() => { + self.afterPaste(files); + }); + } + }) + ] + }); + + + if (this.inputEditorView) this.inputEditorView.destroy(); + this.inputEditorView = new EditorView({ + state: initialState, + parent: this.inputTextEl + }); + } + + /** + * Handler for EOL change events + * Sets the line separator + * @param {string} eol + * @param {boolean} [manual=false] + */ + eolChange(eol, manual=false) { + const eolVal = eolCodeToSeq[eol]; + if (eolVal === undefined) return; + + this.eolState = manual ? 2 : this.eolState; + if (this.eolState < 2 && eolVal === this.getEOLSeq()) return; + + if (this.eolState === 1) { + // Alert + this.app.alert(`Input end of line separator has been detected and changed to ${eolCodeToName[eol]}`, 5000); + } + + // Update the EOL value + const oldInputVal = this.getInput(); + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.eol.reconfigure(EditorState.lineSeparator.of(eolVal)) + }); + + // Reset the input so that lines are recalculated, preserving the old EOL values + this.setInput(oldInputVal); + } + + /** + * Getter for the input EOL sequence + * @returns {string} + */ + getEOLSeq() { + return this.inputEditorView.state.lineBreak; + } + + /** + * Returns whether the input EOL sequence was set manually or has been detected automatically + * @returns {number} - 0 = unset, 1 = detected, 2 = manual + */ + getEOLState() { + return this.eolState; + } + + /** + * Handler for Chr Enc change events + * Sets the input character encoding + * @param {number} chrEncVal + * @param {boolean} [manual=false] - Flag to indicate the encoding was set by the user + * @param {boolean} [internal=false] - Flag to indicate this was set internally, i.e. by loading from URI + */ + chrEncChange(chrEncVal, manual=false, internal=false) { + if (typeof chrEncVal !== "number") return; + this.inputChrEnc = chrEncVal; + this.encodingState = manual ? 2 : this.encodingState; + if (!internal) { + this.inputChange(); + } + } + + /** + * Getter for the input character encoding + * @returns {number} + */ + getChrEnc() { + return this.inputChrEnc; + } + + /** + * Returns whether the input character encoding was set manually or has been detected automatically + * @returns {number} - 0 = unset, 1 = detected, 2 = manual + */ + getEncodingState() { + return this.encodingState; + } + + /** + * Sets word wrap on the input editor + * @param {boolean} wrap + */ + setWordWrap(wrap) { + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.lineWrapping.reconfigure( + wrap ? EditorView.lineWrapping : [] + ) + }); + } + + /** + * Gets the value of the current input + * @returns {string} + */ + getInput() { + const doc = this.inputEditorView.state.doc; + const eol = this.getEOLSeq(); + return doc.sliceString(0, doc.length, eol); + } + + /** + * Sets the value of the current input + * @param {string} data + * @param {boolean} [silent=false] + */ + setInput(data, silent=false) { + const lineLengthThreshold = 131072; // 128KB + let wrap = this.app.options.wordWrap; + if (data.length > lineLengthThreshold) { + const lines = data.split(this.getEOLSeq()); + const longest = lines.reduce((a, b) => + a > b.length ? a : b.length, 0 + ); + if (longest > lineLengthThreshold) { + // If we are exceeding the max line length, turn off word wrap + wrap = false; + this.app.alert("Maximum line length exceeded. Word wrap will be temporarily disabled to improve performance.", 20000); + } + } + + // If turning word wrap off, do it before we populate the editor for performance reasons + if (!wrap) this.setWordWrap(wrap); + + // We use setTimeout here to delay the editor dispatch until the next event cycle, + // ensuring all async actions have completed before attempting to set the contents + // of the editor. This is mainly with the above call to setWordWrap() in mind. + setTimeout(() => { + // Insert data into editor, overwriting any previous contents + this.silentInputChange = silent; + this.inputEditorView.dispatch({ + changes: { + from: 0, + to: this.inputEditorView.state.doc.length, + insert: data + } + }); + + // If turning word wrap on, do it after we populate the editor + if (wrap) + setTimeout(() => { + this.setWordWrap(wrap); + }); + }); + } + /** * Calculates the maximum number of tabs to display */ @@ -72,7 +339,7 @@ class InputWaiter { action: "updateMaxTabs", data: { maxTabs: numTabs, - activeTab: this.manager.tabs.getActiveInputTab() + activeTab: this.manager.tabs.getActiveTab("input") } }); } @@ -93,6 +360,10 @@ class InputWaiter { log.debug("Adding new InputWorker"); this.inputWorker = new InputWorker(); + this.inputWorker.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); this.inputWorker.postMessage({ action: "updateMaxWorkers", data: this.maxWorkers @@ -101,13 +372,10 @@ class InputWaiter { action: "updateMaxTabs", data: { maxTabs: this.maxTabs, - activeTab: this.manager.tabs.getActiveInputTab() + activeTab: this.manager.tabs.getActiveTab("input") } }); - this.inputWorker.postMessage({ - action: "setLogLevel", - data: log.getLevel() - }); + this.inputWorker.addEventListener("message", this.handleInputWorkerMessage.bind(this)); } @@ -136,11 +404,20 @@ class InputWaiter { if (this.loaderWorkers.length === this.maxWorkers) { return -1; } - log.debug("Adding new LoaderWorker."); + log.debug(`Adding new LoaderWorker (${this.loaderWorkers.length + 1}/${this.maxWorkers}).`); const newWorker = new LoaderWorker(); const workerId = this.workerId++; newWorker.addEventListener("message", this.handleLoaderMessage.bind(this)); - newWorker.postMessage({id: workerId}); + newWorker.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); + newWorker.postMessage({ + action: "setID", + data: { + id: workerId + } + }); const newWorkerObj = { worker: newWorker, id: workerId @@ -205,8 +482,11 @@ class InputWaiter { const idx = this.getLoaderWorkerIndex(inputData.workerId); if (idx === -1) return; this.loaderWorkers[idx].worker.postMessage({ - file: inputData.file, - inputNum: inputData.inputNum + action: "loadFile", + data: { + file: inputData.file, + inputNum: inputData.inputNum + } }); } @@ -221,7 +501,7 @@ class InputWaiter { if (Object.prototype.hasOwnProperty.call(r, "progress") && Object.prototype.hasOwnProperty.call(r, "inputNum")) { - this.manager.tabs.updateInputTabProgress(r.inputNum, r.progress, 100); + this.manager.tabs.updateTabProgress(r.inputNum, r.progress, 100, "input"); } const transferable = Object.prototype.hasOwnProperty.call(r, "fileBuffer") ? [r.fileBuffer] : undefined; @@ -233,7 +513,7 @@ class InputWaiter { /** - * Handler for messages sent back by the inputWorker + * Handler for messages sent back by the InputWorker * * @param {MessageEvent} e */ @@ -245,7 +525,7 @@ class InputWaiter { return; } - log.debug(`Receiving ${r.action} from InputWorker.`); + log.debug(`Receiving '${r.action}' from InputWorker.`); switch (r.action) { case "activateLoaderWorker": @@ -264,13 +544,13 @@ class InputWaiter { this.changeTab(r.data, this.app.options.syncTabs); break; case "updateTabHeader": - this.manager.tabs.updateInputTabHeader(r.data.inputNum, r.data.input); + this.manager.tabs.updateTabHeader(r.data.inputNum, r.data.input, "input"); break; case "loadingInfo": this.showLoadingInfo(r.data, true); break; case "setInput": - debounce(this.set, 50, "setInput", this, [r.data.inputObj, r.data.silent])(); + this.set(r.data.inputNum, r.data.inputObj, r.data.silent); break; case "inputAdded": this.inputAdded(r.data.changeTab, r.data.inputNum); @@ -281,8 +561,8 @@ class InputWaiter { case "queueInputError": this.manager.worker.queueInputError(r.data); break; - case "bakeAllInputs": - this.manager.worker.bakeAllInputs(r.data); + case "bakeInputs": + this.manager.worker.bakeInputs(r.data); break; case "displayTabSearchResults": this.displayTabSearchResults(r.data); @@ -291,10 +571,7 @@ class InputWaiter { this.app.handleError(r.data); break; case "setUrl": - this.setUrl(r.data); - break; - case "inputSwitch": - this.manager.output.inputSwitch(r.data); + this.app.updateURL(r.data.includeInput, r.data.input); break; case "getInput": case "getInputNums": @@ -325,99 +602,130 @@ class InputWaiter { /** * Sets the input in the input area * - * @param {object} inputData - Object containing the input and its metadata - * @param {number} inputData.inputNum - The unique inputNum for the selected input - * @param {string | object} inputData.input - The actual input data - * @param {string} inputData.name - The name of the input file - * @param {number} inputData.size - The size in bytes of the input file - * @param {string} inputData.type - The MIME type of the input file - * @param {number} inputData.progress - The load progress of the input file + * @param {number} inputNum + * @param {Object} inputData - Object containing the input and its metadata + * @param {string} type + * @param {ArrayBuffer} buffer + * @param {string} stringSample + * @param {Object} file + * @param {string} file.name + * @param {number} file.size + * @param {string} file.type + * @param {string} status + * @param {number} progress + * @param {number} encoding + * @param {string} eolSequence * @param {boolean} [silent=false] - If false, fires the manager statechange event */ - async set(inputData, silent=false) { + async set(inputNum, inputData, silent=false) { return new Promise(function(resolve, reject) { - const activeTab = this.manager.tabs.getActiveInputTab(); - if (inputData.inputNum !== activeTab) return; - - const inputText = document.getElementById("input-text"); - - if (typeof inputData.input === "string") { - inputText.value = inputData.input; - const fileOverlay = document.getElementById("input-file"), - fileName = document.getElementById("input-file-name"), - fileSize = document.getElementById("input-file-size"), - fileType = document.getElementById("input-file-type"), - fileLoaded = document.getElementById("input-file-loaded"); - - fileOverlay.style.display = "none"; - fileName.textContent = ""; - fileSize.textContent = ""; - fileType.textContent = ""; - fileLoaded.textContent = ""; - - inputText.style.overflow = "auto"; - inputText.classList.remove("blur"); - inputText.scroll(0, 0); - - const lines = inputData.input.length < (this.app.options.ioDisplayThreshold * 1024) ? - inputData.input.count("\n") + 1 : null; - this.setInputInfo(inputData.input.length, lines); - - // Set URL to current input - const inputStr = toBase64(inputData.input, "A-Za-z0-9+/"); - if (inputStr.length > 0 && inputStr.length <= 68267) { - this.setUrl({ - includeInput: true, - input: inputStr - }); - } - - if (!silent) window.dispatchEvent(this.manager.statechange); - } else { - this.setFile(inputData, silent); + const activeTab = this.manager.tabs.getActiveTab("input"); + if (inputNum !== activeTab) { + this.changeTab(inputNum, this.app.options.syncTabs); + return; } + // Update current character encoding + this.inputChrEnc = inputData.encoding; + + // Update current eol sequence + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.eol.reconfigure( + EditorState.lineSeparator.of(inputData.eolSequence) + ) + }); + + // Handle file previews + if (inputData.file) { + this.setFile(inputNum, inputData); + } else { + this.clearFile(inputNum); + } + + // Decode the data to a string + this.manager.timing.recordTime("inputEncodingStart", inputNum); + let inputVal; + if (this.getChrEnc() > 0) { + inputVal = cptable.utils.decode(this.inputChrEnc, new Uint8Array(inputData.buffer)); + } else { + inputVal = Utils.arrayBufferToStr(inputData.buffer); + } + this.manager.timing.recordTime("inputEncodingEnd", inputNum); + + // Populate the input editor + this.setInput(inputVal, silent); + + // Set URL to current input + if (inputVal.length >= 0 && inputVal.length <= 51200) { + const inputStr = toBase64(inputVal, "A-Za-z0-9+/"); + this.app.updateURL(true, inputStr); + } }.bind(this)); } /** * Displays file details * - * @param {object} inputData - Object containing the input and its metadata - * @param {number} inputData.inputNum - The unique inputNum for the selected input - * @param {string | object} inputData.input - The actual input data - * @param {string} inputData.name - The name of the input file - * @param {number} inputData.size - The size in bytes of the input file - * @param {string} inputData.type - The MIME type of the input file - * @param {number} inputData.progress - The load progress of the input file - * @param {boolean} [silent=true] - If false, fires the manager statechange event + * @param {number} inputNum + * @param {Object} inputData - Object containing the input and its metadata + * @param {string} type + * @param {ArrayBuffer} buffer + * @param {string} stringSample + * @param {Object} file + * @param {string} file.name + * @param {number} file.size + * @param {string} file.type + * @param {string} status + * @param {number} progress */ - setFile(inputData, silent=true) { - const activeTab = this.manager.tabs.getActiveInputTab(); - if (inputData.inputNum !== activeTab) return; + setFile(inputNum, inputData) { + const activeTab = this.manager.tabs.getActiveTab("input"); + if (inputNum !== activeTab) return; - const fileOverlay = document.getElementById("input-file"), - fileName = document.getElementById("input-file-name"), - fileSize = document.getElementById("input-file-size"), - fileType = document.getElementById("input-file-type"), - fileLoaded = document.getElementById("input-file-loaded"); + // Create file details panel + this.fileDetails = { + fileDetails: inputData.file, + progress: inputData.progress, + status: inputData.status, + buffer: inputData.buffer, + renderPreview: this.app.options.imagePreview, + toggleHandler: this.toggleFileDetails.bind(this), + hidden: false + }; + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.fileDetailsPanel.reconfigure( + fileDetailsPanel(this.fileDetails) + ) + }); + } - fileOverlay.style.display = "block"; - fileName.textContent = inputData.name; - fileSize.textContent = inputData.size + " bytes"; - fileType.textContent = inputData.type; - if (inputData.status === "error") { - fileLoaded.textContent = "Error"; - fileLoaded.style.color = "#FF0000"; - } else { - fileLoaded.style.color = ""; - fileLoaded.textContent = inputData.progress + "%"; - } + /** + * Clears the file details panel + * + * @param {number} inputNum + */ + clearFile(inputNum) { + const activeTab = this.manager.tabs.getActiveTab("input"); + if (inputNum !== activeTab) return; - this.setInputInfo(inputData.size, null); - this.displayFilePreview(inputData); + // Clear file details panel + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.fileDetailsPanel.reconfigure([]) + }); + } - if (!silent) window.dispatchEvent(this.manager.statechange); + /** + * Handler for file details toggle clicks + * @param {event} e + */ + toggleFileDetails(e) { + $("[data-toggle='tooltip']").tooltip("hide"); + this.fileDetails.hidden = !this.fileDetails.hidden; + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.fileDetailsPanel.reconfigure( + fileDetailsPanel(this.fileDetails) + ) + }); } /** @@ -426,9 +734,9 @@ class InputWaiter { * @param {number} inputNum - The inputNum of the input which has finished loading */ fileLoaded(inputNum) { - this.manager.tabs.updateInputTabProgress(inputNum, 100, 100); + this.manager.tabs.updateTabProgress(inputNum, 100, 100, "input"); - const activeTab = this.manager.tabs.getActiveInputTab(); + const activeTab = this.manager.tabs.getActiveTab("input"); if (activeTab !== inputNum) return; this.inputWorker.postMessage({ @@ -442,63 +750,6 @@ class InputWaiter { this.updateFileProgress(inputNum, 100); } - /** - * Render the input thumbnail - */ - async renderFileThumb() { - const activeTab = this.manager.tabs.getActiveInputTab(), - input = await this.getInputValue(activeTab), - fileThumb = document.getElementById("input-file-thumbnail"); - - if (typeof input === "string" || - !this.app.options.imagePreview) { - this.resetFileThumb(); - return; - } - - const inputArr = new Uint8Array(input), - type = isImage(inputArr); - - if (type && type !== "image/tiff" && inputArr.byteLength <= 512000) { - // Most browsers don't support displaying TIFFs, so ignore them - // Don't render images over 512000 bytes - const blob = new Blob([inputArr], {type: type}), - url = URL.createObjectURL(blob); - fileThumb.src = url; - } else { - this.resetFileThumb(); - } - - } - - /** - * Reset the input thumbnail to the default icon - */ - resetFileThumb() { - const fileThumb = document.getElementById("input-file-thumbnail"); - fileThumb.src = require("../static/images/file-128x128.png").default; - } - - /** - * Shows a chunk of the file in the input behind the file overlay - * - * @param {Object} inputData - Object containing the input data - * @param {number} inputData.inputNum - The inputNum of the file being displayed - * @param {ArrayBuffer} inputData.input - The actual input to display - */ - displayFilePreview(inputData) { - const activeTab = this.manager.tabs.getActiveInputTab(), - input = inputData.input, - inputText = document.getElementById("input-text"); - if (inputData.inputNum !== activeTab) return; - inputText.style.overflow = "hidden"; - inputText.classList.add("blur"); - inputText.value = Utils.printable(Utils.arrayBufferToStr(input.slice(0, 4096))); - - this.renderFileThumb(); - - } - /** * Updates the displayed load progress for a file * @@ -506,17 +757,16 @@ class InputWaiter { * @param {number | string} progress - Either a number or "error" */ updateFileProgress(inputNum, progress) { - const activeTab = this.manager.tabs.getActiveInputTab(); + const activeTab = this.manager.tabs.getActiveTab("input"); if (inputNum !== activeTab) return; - const fileLoaded = document.getElementById("input-file-loaded"); - if (progress === "error") { - fileLoaded.textContent = "Error"; - fileLoaded.style.color = "#FF0000"; - } else { - fileLoaded.textContent = progress + "%"; - fileLoaded.style.color = ""; - } + this.fileDetails.progress = progress; + if (progress === "error") this.fileDetails.status = "error"; + this.inputEditorView.dispatch({ + effects: this.inputEditorConf.fileDetailsPanel.reconfigure( + fileDetailsPanel(this.fileDetails) + ) + }); } /** @@ -524,46 +774,44 @@ class InputWaiter { * * @param {number} inputNum * @param {string | ArrayBuffer} value - * @param {boolean} [force=false] - If true, forces the value to be updated even if the type is different to the currently stored type */ updateInputValue(inputNum, value, force=false) { - let includeInput = false; - const recipeStr = toBase64(value, "A-Za-z0-9+/"); // B64 alphabet with no padding - if (recipeStr.length > 0 && recipeStr.length <= 68267) { - includeInput = true; - } - this.setUrl({ - includeInput: includeInput, - input: recipeStr - }); + // Prepare the value as a buffer (full value) and a string sample (up to 4096 bytes) + let buffer; + let stringSample = ""; - // Value is either a string set by the input or an ArrayBuffer from a LoaderWorker, - // so is safe to use typeof === "string" - const transferable = (typeof value !== "string") ? [value] : undefined; + // If value is a string, interpret it using the specified character encoding + const tabNum = this.manager.tabs.getActiveTab("input"); + this.manager.timing.recordTime("inputEncodingStart", tabNum); + if (typeof value === "string") { + stringSample = value.slice(0, 4096); + if (this.getChrEnc() > 0) { + buffer = cptable.utils.encode(this.getChrEnc(), value); + buffer = new Uint8Array(buffer).buffer; + } else { + buffer = Utils.strToArrayBuffer(value); + } + } else { + buffer = value; + stringSample = Utils.arrayBufferToStr(value.slice(0, 4096)); + } + this.manager.timing.recordTime("inputEncodingEnd", tabNum); + + // Update the deep link + const recipeStr = buffer.byteLength < 51200 ? toBase64(buffer, "A-Za-z0-9+/") : ""; // B64 alphabet with no padding + const includeInput = recipeStr.length > 0 && buffer.byteLength < 51200; + this.app.updateURL(includeInput, recipeStr); + + // Post new value to the InputWorker + const transferable = [buffer]; this.inputWorker.postMessage({ action: "updateInputValue", data: { inputNum: inputNum, - value: value, - force: force - } - }, transferable); - } - - /** - * Updates the .data property for the input of the specified inputNum. - * Used for switching the output into the input - * - * @param {number} inputNum - The inputNum of the input we're changing - * @param {object} inputData - The new data object - */ - updateInputObj(inputNum, inputData) { - const transferable = (typeof inputData !== "string") ? [inputData.fileBuffer] : undefined; - this.inputWorker.postMessage({ - action: "updateInputObj", - data: { - inputNum: inputNum, - data: inputData + buffer: buffer, + stringSample: stringSample, + encoding: this.getChrEnc(), + eolSequence: this.getEOLSeq() } }, transferable); } @@ -576,7 +824,7 @@ class InputWaiter { */ async getInputValue(inputNum) { return await new Promise(resolve => { - this.getInput(inputNum, false, r => { + this.getInputFromWorker(inputNum, false, r => { resolve(r.data); }); }); @@ -590,7 +838,7 @@ class InputWaiter { */ async getInputObj(inputNum) { return await new Promise(resolve => { - this.getInput(inputNum, true, r => { + this.getInputFromWorker(inputNum, true, r => { resolve(r.data); }); }); @@ -604,7 +852,7 @@ class InputWaiter { * @param {Function} callback - The callback to execute when the input is returned * @returns {ArrayBuffer | string | object} */ - getInput(inputNum, getObj, callback) { + getInputFromWorker(inputNum, getObj, callback) { const id = this.callbackID++; this.callbacks[id] = callback; @@ -647,129 +895,91 @@ class InputWaiter { }); } - - /** - * Displays information about the input. - * - * @param {number} length - The length of the current input string - * @param {number} lines - The number of the lines in the current input string - */ - setInputInfo(length, lines) { - let width = length.toString().length.toLocaleString(); - width = width < 2 ? 2 : width; - - const lengthStr = length.toString().padStart(width, " ").replace(/ /g, " "); - let msg = "length: " + lengthStr; - - if (typeof lines === "number") { - const linesStr = lines.toString().padStart(width, " ").replace(/ /g, " "); - msg += "
lines: " + linesStr; - } - - document.getElementById("input-info").innerHTML = msg; - - } - - /** - * Handler for input change events. - * Debounces the input so we don't call autobake too often. - * - * @param {event} e - */ - debounceInputChange(e) { - debounce(this.inputChange, 50, "inputChange", this, [e])(); - } - /** * Handler for input change events. * Updates the value stored in the inputWorker + * Debounces the input so we don't call autobake too often. * * @param {event} e * * @fires Manager#statechange */ inputChange(e) { - // Ignore this function if the input is a file - const fileOverlay = document.getElementById("input-file"); - if (fileOverlay.style.display === "block") return; + // Change debounce delay based on input length + const inputLength = this.inputEditorView.state.doc.length; + let delay; + if (inputLength < 10000) delay = 20; + else if (inputLength < 100000) delay = 50; + else if (inputLength < 1000000) delay = 200; + else delay = 500; - // Remove highlighting from input and output panes as the offsets might be different now - this.manager.highlighter.removeHighlights(); + debounce(function(e) { + const value = this.getInput(); + const activeTab = this.manager.tabs.getActiveTab("input"); - const textArea = document.getElementById("input-text"); - const value = (textArea.value !== undefined) ? textArea.value : ""; - const activeTab = this.manager.tabs.getActiveInputTab(); + this.updateInputValue(activeTab, value); + this.inputWorker.postMessage({ + action: "updateTabHeader", + data: activeTab + }); - this.app.progress = 0; - - const lines = value.length < (this.app.options.ioDisplayThreshold * 1024) ? - (value.count("\n") + 1) : null; - this.setInputInfo(value.length, lines); - this.updateInputValue(activeTab, value); - this.manager.tabs.updateInputTabHeader(activeTab, value.replace(/[\n\r]/g, "").slice(0, 100)); - - if (e && this.badKeys.indexOf(e.keyCode) < 0) { // Fire the statechange event as the input has been modified window.dispatchEvent(this.manager.statechange); - } + }, delay, "inputChange", this, [e])(); } /** - * Handler for input paste events - * Checks that the size of the input is below the display limit, otherwise treats it as a file/blob + * Handler that fires just after input paste events. + * Checks whether the EOL separator or character encoding should be updated. * - * @param {event} e + * @param {File[]} files - An array of any files that were included in the paste event */ - async inputPaste(e) { - e.preventDefault(); - e.stopPropagation(); + afterPaste(files) { + if (files.length > 0) { + this.loadUIFiles(files); + } + // If EOL has been fixed, skip this. + if (this.eolState > 1) return; - const self = this; - /** - * Triggers the input file/binary data overlay - * - * @param {string} pastedData - */ - function triggerOverlay(pastedData) { - const file = new File([pastedData], "PastedData", { - type: "text/plain", - lastModified: Date.now() - }); + const inputText = this.getInput(); - self.loadUIFiles([file]); + // Detect most likely EOL sequence + const eolCharCounts = { + "LF": inputText.count("\u000a"), + "VT": inputText.count("\u000b"), + "FF": inputText.count("\u000c"), + "CR": inputText.count("\u000d"), + "CRLF": inputText.count("\u000d\u000a"), + "NEL": inputText.count("\u0085"), + "LS": inputText.count("\u2028"), + "PS": inputText.count("\u2029") + }; + + // If all zero, leave alone + const total = Object.values(eolCharCounts).reduce((acc, curr) => { + return acc + curr; + }, 0); + if (total === 0) return; + + // Find most prevalent line ending sequence + const highest = Object.entries(eolCharCounts).reduce((acc, curr) => { + return curr[1] > acc[1] ? curr : acc; + }, ["LF", 0]); + let choice = highest[0]; + + // If CRLF not zero and more than half the highest alternative, choose CRLF + if ((eolCharCounts.CRLF * 2) > highest[1]) { + choice = "CRLF"; } - const pastedData = e.clipboardData.getData("Text"); - const inputText = document.getElementById("input-text"); - const selStart = inputText.selectionStart; - const selEnd = inputText.selectionEnd; - const startVal = inputText.value.slice(0, selStart); - const endVal = inputText.value.slice(selEnd); - const val = startVal + pastedData + endVal; + const eolVal = eolCodeToSeq[choice]; + if (eolVal === this.getEOLSeq()) return; - if (val.length >= (this.app.options.ioDisplayThreshold * 1024)) { - // Data too large to display, use overlay - triggerOverlay(val); - return false; - } else if (await this.preserveCarriageReturns(val)) { - // Data contains a carriage return and the user doesn't wish to edit it, use overlay - // We check this in a separate condition to make sure it is not run unless absolutely - // necessary. - triggerOverlay(val); - return false; - } else { - // Pasting normally fires the inputChange() event before - // changing the value, so instead change it here ourselves - // and manually fire inputChange() - inputText.value = val; - inputText.setSelectionRange(selStart + pastedData.length, selStart + pastedData.length); - // Don't debounce here otherwise the keyup event for the Ctrl key will cancel an autobake - // (at least for large inputs) - this.inputChange(e, true); - } + // Setting automatically + this.eolState = 1; + this.eolChange(choice); } - /** * Handler for input dragover events. * Gives the user a visual cue to show that items can be dropped here. @@ -783,7 +993,7 @@ class InputWaiter { e.stopPropagation(); e.preventDefault(); - e.target.closest("#input-text,#input-file").classList.add("dropping-file"); + e.target.closest("#input-text").classList.add("dropping-file"); } /** @@ -795,7 +1005,12 @@ class InputWaiter { inputDragleave(e) { e.stopPropagation(); e.preventDefault(); - e.target.closest("#input-text,#input-file").classList.remove("dropping-file"); + + // Dragleave often fires when moving between lines in the editor. + // If the from element is within the input-text element, we are still on target. + if (!this.inputTextEl.contains(e.fromElement)) { + e.target.closest("#input-text").classList.remove("dropping-file"); + } } /** @@ -804,27 +1019,107 @@ class InputWaiter { * * @param {event} e */ - inputDrop(e) { + async inputDrop(e) { // This will be set if we're dragging an operation if (e.dataTransfer.effectAllowed === "move") return false; e.stopPropagation(); e.preventDefault(); + e.target.closest("#input-text").classList.remove("dropping-file"); - const text = e.dataTransfer.getData("Text"); + // Dropped text is handled by the editor itself + if (e.dataTransfer.getData("Text")) return; - e.target.closest("#input-text,#input-file").classList.remove("dropping-file"); + // Dropped files + if (e?.dataTransfer?.files?.length > 0) { + let files = []; - if (text) { - // Append the text to the current input and fire inputChange() - document.getElementById("input-text").value += text; - this.inputChange(e); - return; + // Handling the files as FileSystemEntry objects allows us to open directories, + // but relies on a function that may be deprecated in future. + if (Object.prototype.hasOwnProperty.call(DataTransferItem.prototype, "webkitGetAsEntry")) { + const fileEntries = await this.getAllFileEntries(e.dataTransfer.items); + // Read all FileEntry objects into File objects + files = await Promise.all(fileEntries.map(async fe => await this.getFile(fe))); + } else { + files = e.dataTransfer.files; + } + + this.loadUIFiles(files); } + } - if (e.dataTransfer.files && e.dataTransfer.files.length > 0) { - this.loadUIFiles(e.dataTransfer.files); + /** + * + * @param {DataTransferItemList} dataTransferItemList + * @returns {FileSystemEntry[]} + */ + async getAllFileEntries(dataTransferItemList) { + const fileEntries = []; + // Use BFS to traverse entire directory/file structure + const queue = []; + // Unfortunately dataTransferItemList is not iterable i.e. no forEach + for (let i = 0; i < dataTransferItemList.length; i++) { + // Note webkitGetAsEntry a non-standard feature and may change + // Usage is necessary for handling directories + queue.push(dataTransferItemList[i].webkitGetAsEntry()); + } + while (queue.length > 0) { + const entry = queue.shift(); + if (entry.isFile) { + fileEntries.push(entry); + } else if (entry.isDirectory) { + queue.push(...await this.readAllDirectoryEntries(entry.createReader())); + } + } + return fileEntries; + } + + /** + * Get all the entries (files or sub-directories) in a directory by calling + * readEntries until it returns empty array + * + * @param {FileSystemDirectoryReader} directoryReader + * @returns {FileSystemEntry[]} + */ + async readAllDirectoryEntries(directoryReader) { + const entries = []; + let readEntries = await this.readEntriesPromise(directoryReader); + while (readEntries.length > 0) { + entries.push(...readEntries); + readEntries = await this.readEntriesPromise(directoryReader); + } + return entries; + } + + /** + * Wrap readEntries in a promise to make working with readEntries easier. + * readEntries will return only some of the entries in a directory + * e.g. Chrome returns at most 100 entries at a time + * + * @param {FileSystemDirectoryReader} directoryReader + * @returns {Promise} + */ + async readEntriesPromise(directoryReader) { + try { + return await new Promise((resolve, reject) => { + directoryReader.readEntries(resolve, reject); + }); + } catch (err) { + log.error(err); + } + } + + /** + * Reads a FileEntry and returns it as a File object + * @param {FileEntry} fileEntry + * @returns {File} + */ + async getFile(fileEntry) { + try { + return new Promise((resolve, reject) => fileEntry.file(resolve, reject)); + } catch (err) { + log.error(err); } } @@ -844,41 +1139,19 @@ class InputWaiter { } /** - * Checks if an input contains carriage returns. - * If a CR is detected, checks if the preserve CR option has been set, - * and if not, asks the user for their preference. - * - * @param {string} input - The input to be checked - * @returns {boolean} - If true, the input contains a CR which should be - * preserved, so display an overlay so it can't be edited + * Handler for open input button click. + * Opens the open file dialog. */ - async preserveCarriageReturns(input) { - if (input.indexOf("\r") < 0) return false; + inputOpenClick() { + document.getElementById("open-file").click(); + } - const optionsStr = "This behaviour can be changed in the Options pane"; - const preserveStr = `A carriage return (\\r, 0x0d) was detected in your input. To preserve it, editing has been disabled.
${optionsStr}`; - const dontPreserveStr = `A carriage return (\\r, 0x0d) was detected in your input. It has not been preserved.
${optionsStr}`; - - switch (this.app.options.preserveCR) { - case "always": - this.app.alert(preserveStr, 6000); - return true; - case "never": - this.app.alert(dontPreserveStr, 6000); - return false; - } - - // Only preserve for high-entropy inputs - const data = Utils.strToArrayBuffer(input); - const entropy = Utils.calculateShannonEntropy(data); - - if (entropy > 6) { - this.app.alert(preserveStr, 6000); - return true; - } - - this.app.alert(dontPreserveStr, 6000); - return false; + /** + * Handler for open folder button click + * Opens the open folder dialog. + */ + folderOpenClick() { + document.getElementById("open-folder").click(); } /** @@ -888,7 +1161,7 @@ class InputWaiter { */ loadUIFiles(files) { const numFiles = files.length; - const activeTab = this.manager.tabs.getActiveInputTab(); + const activeTab = this.manager.tabs.getActiveTab("input"); log.debug(`Loading ${numFiles} files.`); // Display the number of files as pending so the user @@ -913,22 +1186,6 @@ class InputWaiter { }); } - /** - * Handler for open input button click. - * Opens the open file dialog. - */ - inputOpenClick() { - document.getElementById("open-file").click(); - } - - /** - * Handler for open folder button click - * Opens the open folder dialog. - */ - folderOpenClick() { - document.getElementById("open-folder").click(); - } - /** * Display the loaded files information in the input header. * Also, sets the background of the Input header to be a progress bar @@ -987,7 +1244,7 @@ class InputWaiter { setTimeout(function() { this.inputWorker.postMessage({ action: "getLoadProgress", - data: this.manager.tabs.getActiveInputTab() + data: this.manager.tabs.getActiveTab("input") }); }.bind(this), 100); } @@ -999,9 +1256,9 @@ class InputWaiter { * @param {number} inputNum - The inputNum of the tab to change to * @param {boolean} [changeOutput=false] - If true, also changes the output */ - changeTab(inputNum, changeOutput) { - if (this.manager.tabs.getInputTabItem(inputNum) !== null) { - this.manager.tabs.changeInputTab(inputNum); + changeTab(inputNum, changeOutput=false) { + if (this.manager.tabs.getTabItem(inputNum, "input") !== null) { + this.manager.tabs.changeTab(inputNum, "input"); this.inputWorker.postMessage({ action: "setInput", data: { @@ -1010,7 +1267,7 @@ class InputWaiter { } }); } else { - const minNum = Math.min(...this.manager.tabs.getInputTabList()); + const minNum = Math.min(...this.manager.tabs.getTabList("input")); let direction = "right"; if (inputNum < minNum) { direction = "left"; @@ -1027,6 +1284,9 @@ class InputWaiter { if (changeOutput) { this.manager.output.changeTab(inputNum, false); } + + // Set cursor focus to current tab + this.inputEditorView.focus(); } /** @@ -1053,8 +1313,13 @@ class InputWaiter { this.manager.output.removeAllOutputs(); this.manager.output.terminateZipWorker(); - this.manager.highlighter.removeHighlights(); - getSelection().removeAllRanges(); + this.eolState = 0; + this.encodingState = 0; + this.manager.output.eolState = 0; + this.manager.output.encodingState = 0; + + this.initEditor(); + this.manager.output.initEditor(); const tabsList = document.getElementById("input-tabs"); const tabsListChildren = tabsList.children; @@ -1079,36 +1344,19 @@ class InputWaiter { this.setupInputWorker(); this.manager.worker.setupChefWorker(); this.addInput(true); - this.bakeAll(); } /** - * Handler for clear IO click event. - * Resets the input for the current tab + * Sets the console log level in the workers. */ - clearIoClick() { - const inputNum = this.manager.tabs.getActiveInputTab(); - if (inputNum === -1) return; - - this.manager.highlighter.removeHighlights(); - getSelection().removeAllRanges(); - - this.updateInputValue(inputNum, "", true); - - this.set({ - inputNum: inputNum, - input: "" + setLogLevel() { + this.loaderWorkers.forEach(w => { + w.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); }); - this.manager.tabs.updateInputTabHeader(inputNum, ""); - } - - /** - * Sets the console log level in the worker. - * - * @param {string} level - */ - setLogLevel(level) { if (!this.inputWorker) return; this.inputWorker.postMessage({ action: "setLogLevel", @@ -1163,12 +1411,12 @@ class InputWaiter { * @param {number} inputNum - The inputNum of the new tab * @param {boolean} [changeTab=true] - If true, changes to the new tab once it's been added */ - addTab(inputNum, changeTab = true) { + addTab(inputNum, changeTab=true) { const tabsWrapper = document.getElementById("input-tabs"), numTabs = tabsWrapper.children.length; - if (!this.manager.tabs.getInputTabItem(inputNum) && numTabs < this.maxTabs) { - const newTab = this.manager.tabs.createInputTabElement(inputNum, changeTab); + if (!this.manager.tabs.getTabItem(inputNum, "input") && numTabs < this.maxTabs) { + const newTab = this.manager.tabs.createTabElement(inputNum, changeTab, "input"); tabsWrapper.appendChild(newTab); if (numTabs > 0) { @@ -1198,7 +1446,7 @@ class InputWaiter { * @param {boolean} tabsRight - True if there are input tabs to the right of the displayed tabs */ refreshTabs(nums, activeTab, tabsLeft, tabsRight) { - this.manager.tabs.refreshInputTabs(nums, activeTab, tabsLeft, tabsRight); + this.manager.tabs.refreshTabs(nums, activeTab, tabsLeft, tabsRight, "input"); this.inputWorker.postMessage({ action: "setInput", @@ -1217,7 +1465,7 @@ class InputWaiter { */ removeInput(inputNum) { let refresh = false; - if (this.manager.tabs.getInputTabItem(inputNum) !== null) { + if (this.manager.tabs.getTabItem(inputNum, "input") !== null) { refresh = true; } this.inputWorker.postMessage({ @@ -1310,7 +1558,7 @@ class InputWaiter { * Changes to the next (right) tab */ changeTabRight() { - const activeTab = this.manager.tabs.getActiveInputTab(); + const activeTab = this.manager.tabs.getActiveTab("input"); if (activeTab === -1) return; this.inputWorker.postMessage({ action: "changeTabRight", @@ -1324,7 +1572,7 @@ class InputWaiter { * Changes to the previous (left) tab */ changeTabLeft() { - const activeTab = this.manager.tabs.getActiveInputTab(); + const activeTab = this.manager.tabs.getActiveTab("input"); if (activeTab === -1) return; this.inputWorker.postMessage({ action: "changeTabLeft", @@ -1339,7 +1587,7 @@ class InputWaiter { */ async goToTab() { const inputNums = await this.getInputNums(); - let tabNum = window.prompt(`Enter tab number (${inputNums.min} - ${inputNums.max}):`, this.manager.tabs.getActiveInputTab().toString()); + let tabNum = window.prompt(`Enter tab number (${inputNums.min} - ${inputNums.max}):`, this.manager.tabs.getActiveTab("input").toString()); if (tabNum === null) return; tabNum = parseInt(tabNum, 10); @@ -1428,17 +1676,22 @@ class InputWaiter { } /** - * Update the input URL to the new value - * - * @param {object} urlData - Object containing the URL data - * @param {boolean} urlData.includeInput - If true, the input is included in the title - * @param {string} urlData.input - The input data to be included + * Handler for incoming postMessages + * If the events data has a `type` property set to `dataSubmit` + * the value property is set to the current input + * @param {event} e + * @param {object} e.data + * @param {string} e.data.type - the type of request, currently the only value is "dataSubmit" + * @param {string} e.data.value - the value of the message */ - setUrl(urlData) { - this.app.updateTitle(urlData.includeInput, urlData.input, true); + handlePostMessage(e) { + log.debug(e); + if ("data" in e && "id" in e.data && "value" in e.data) { + if (e.data.id === "setInput") { + this.setInput(e.data.value); + } + } } - - } export default InputWaiter; diff --git a/src/web/waiters/OperationsWaiter.mjs b/src/web/waiters/OperationsWaiter.mjs index dee0dd06..6c2de064 100755 --- a/src/web/waiters/OperationsWaiter.mjs +++ b/src/web/waiters/OperationsWaiter.mjs @@ -28,17 +28,16 @@ class OperationsWaiter { this.removeIntent = false; } - /** * Handler for search events. * Finds operations which match the given search term and displays them under the search box. * - * @param {event} e + * @param {KeyboardEvent | ClipboardEvent | Event} e */ searchOperations(e) { let ops, selected; - if (e.type === "search" || e.keyCode === 13) { // Search or Return + if ((e.type === "search" && e.target.value !== "") || e.keyCode === 13) { // Search (non-empty) or Return e.preventDefault(); ops = document.querySelectorAll("#search-results li"); if (ops.length) { @@ -49,27 +48,43 @@ class OperationsWaiter { } } + /** + * Sets up the operation element with the correct attributes when selected + * @param {HTMLElement} element + */ + const _selectOperation = (element) => { + element.classList.add("selected-op"); + element.scrollIntoView({block: "nearest"}); + $(element).popover("show"); + e.target.setAttribute("aria-activedescendant", element.id); + }; + + /** + * Sets up the operation element with the correct attributes when deselected + * @param {HTMLElement} element + */ + const _deselectOperation = (element) => { + element.classList.remove("selected-op"); + $(element).popover("hide"); + }; + if (e.keyCode === 40) { // Down e.preventDefault(); ops = document.querySelectorAll("#search-results li"); if (ops.length) { selected = this.getSelectedOp(ops); - if (selected > -1) { - ops[selected].classList.remove("selected-op"); - } + if (selected > -1) _deselectOperation(ops[selected]); if (selected === ops.length-1) selected = -1; - ops[selected+1].classList.add("selected-op"); + _selectOperation(ops[selected+1]); } } else if (e.keyCode === 38) { // Up e.preventDefault(); ops = document.querySelectorAll("#search-results li"); if (ops.length) { selected = this.getSelectedOp(ops); - if (selected > -1) { - ops[selected].classList.remove("selected-op"); - } + if (selected > -1) _deselectOperation(ops[selected]); if (selected === 0) selected = ops.length; - ops[selected-1].classList.add("selected-op"); + _selectOperation(ops[selected-1]); } } else { const searchResultsEl = document.getElementById("search-results"); @@ -83,11 +98,13 @@ class OperationsWaiter { searchResultsEl.removeChild(searchResultsEl.firstChild); } + document.querySelector("#search").removeAttribute("aria-activedescendant"); + $("#categories .show").collapse("hide"); if (str) { const matchedOps = this.filterOperations(str, true); const matchedOpsHtml = matchedOps - .map(v => v.toStubHtml()) + .map((operation, idx) => operation.toStubHtml(false, `search-result-${idx}`)) .join(""); searchResultsEl.innerHTML = matchedOpsHtml; @@ -103,7 +120,7 @@ class OperationsWaiter { * @param {string} searchStr * @param {boolean} highlight - Whether or not to highlight the matching string in the operation * name and description - * @returns {string[]} + * @returns {HTMLOperation[]} */ filterOperations(inStr, highlight) { const matchedOps = []; @@ -168,6 +185,10 @@ class OperationsWaiter { */ opListCreate(e) { this.manager.recipe.createSortableSeedList(e.target); + + // Populate ops total + document.querySelector("#operations .title .op-count").innerText = Object.keys(this.app.operations).length; + this.enableOpsListPopovers(e.target); } @@ -293,6 +314,18 @@ class OperationsWaiter { this.app.resetFavourites(); } + + /** + * Sets whether operation counts are displayed next to a category title + */ + setCatCount() { + if (this.app.options.showCatCount) { + document.querySelectorAll(".category-title .op-count").forEach(el => el.classList.remove("hidden")); + } else { + document.querySelectorAll(".category-title .op-count").forEach(el => el.classList.add("hidden")); + } + } + } export default OperationsWaiter; diff --git a/src/web/waiters/OptionsWaiter.mjs b/src/web/waiters/OptionsWaiter.mjs old mode 100755 new mode 100644 index 5ef517d4..dcb0a5f4 --- a/src/web/waiters/OptionsWaiter.mjs +++ b/src/web/waiters/OptionsWaiter.mjs @@ -26,33 +26,31 @@ class OptionsWaiter { * @param {Object} options */ load(options) { - for (const option in options) { - this.app.options[option] = options[option]; - } + Object.assign(this.app.options, options); // Set options to match object - const cboxes = document.querySelectorAll("#options-body input[type=checkbox]"); - let i; - for (i = 0; i < cboxes.length; i++) { - cboxes[i].checked = this.app.options[cboxes[i].getAttribute("option")]; - } + document.querySelectorAll("#options-body input[type=checkbox]").forEach(cbox => { + cbox.checked = this.app.options[cbox.getAttribute("option")]; + }); - const nboxes = document.querySelectorAll("#options-body input[type=number]"); - for (i = 0; i < nboxes.length; i++) { - nboxes[i].value = this.app.options[nboxes[i].getAttribute("option")]; - nboxes[i].dispatchEvent(new CustomEvent("change", {bubbles: true})); - } + document.querySelectorAll("#options-body input[type=number]").forEach(nbox => { + nbox.value = this.app.options[nbox.getAttribute("option")]; + nbox.dispatchEvent(new CustomEvent("change", {bubbles: true})); + }); - const selects = document.querySelectorAll("#options-body select"); - for (i = 0; i < selects.length; i++) { - const val = this.app.options[selects[i].getAttribute("option")]; + document.querySelectorAll("#options-body select").forEach(select => { + const val = this.app.options[select.getAttribute("option")]; if (val) { - selects[i].value = val; - selects[i].dispatchEvent(new CustomEvent("change", {bubbles: true})); + select.value = val; + select.dispatchEvent(new CustomEvent("change", {bubbles: true})); } else { - selects[i].selectedIndex = 0; + select.selectedIndex = 0; } - } + }); + + // Initialise options + this.setWordWrap(); + this.manager.ops.setCatCount(); } @@ -136,19 +134,8 @@ class OptionsWaiter { * Sets or unsets word wrap on the input and output depending on the wordWrap option value. */ setWordWrap() { - document.getElementById("input-text").classList.remove("word-wrap"); - document.getElementById("output-text").classList.remove("word-wrap"); - document.getElementById("output-html").classList.remove("word-wrap"); - document.getElementById("input-highlighter").classList.remove("word-wrap"); - document.getElementById("output-highlighter").classList.remove("word-wrap"); - - if (!this.app.options.wordWrap) { - document.getElementById("input-text").classList.add("word-wrap"); - document.getElementById("output-text").classList.add("word-wrap"); - document.getElementById("output-html").classList.add("word-wrap"); - document.getElementById("input-highlighter").classList.add("word-wrap"); - document.getElementById("output-highlighter").classList.add("word-wrap"); - } + this.manager.input.setWordWrap(this.app.options.wordWrap); + this.manager.output.setWordWrap(this.app.options.wordWrap); } @@ -159,7 +146,6 @@ class OptionsWaiter { */ themeChange(e) { const themeClass = e.target.value; - this.changeTheme(themeClass); } @@ -174,9 +160,36 @@ class OptionsWaiter { // Update theme selection const themeSelect = document.getElementById("theme"); - themeSelect.selectedIndex = themeSelect.querySelector(`option[value="${theme}"`).index; + let themeOption = themeSelect.querySelector(`option[value="${theme}"]`); + + if (!themeOption) { + const preferredColorScheme = this.getPreferredColorScheme(); + document.querySelector(":root").className = preferredColorScheme; + themeOption = themeSelect.querySelector(`option[value="${preferredColorScheme}"]`); + } + + themeSelect.selectedIndex = themeOption.index; } + /** + * Applies the user's preferred color scheme using the `prefers-color-scheme` media query. + */ + applyPreferredColorScheme() { + const themeFromStorage = this.app?.options?.theme; + let theme = themeFromStorage; + if (!theme) { + theme = this.getPreferredColorScheme(); + } + this.changeTheme(theme); + } + + /** + * Get the user's preferred color scheme using the `prefers-color-scheme` media query. + */ + getPreferredColorScheme() { + const prefersDarkScheme = window.matchMedia("(prefers-color-scheme: dark)").matches; + return prefersDarkScheme ? "dark" : "classic"; + } /** * Changes the console logging level. @@ -188,6 +201,8 @@ class OptionsWaiter { log.setLevel(level, false); this.manager.worker.setLogLevel(); this.manager.input.setLogLevel(); + this.manager.output.setLogLevel(); + this.manager.background.setLogLevel(); } } diff --git a/src/web/waiters/OutputWaiter.mjs b/src/web/waiters/OutputWaiter.mjs index 0eb6baec..2b2cb096 100755 --- a/src/web/waiters/OutputWaiter.mjs +++ b/src/web/waiters/OutputWaiter.mjs @@ -5,11 +5,43 @@ * @license Apache-2.0 */ -import Utils, { debounce } from "../../core/Utils.mjs"; +import Utils, {debounce} from "../../core/Utils.mjs"; import Dish from "../../core/Dish.mjs"; +import {isUTF8, CHR_ENC_SIMPLE_REVERSE_LOOKUP} from "../../core/lib/ChrEnc.mjs"; +import {detectFileType} from "../../core/lib/FileType.mjs"; import FileSaver from "file-saver"; import ZipWorker from "worker-loader?inline=no-fallback!../workers/ZipWorker.mjs"; +import { + EditorView, + keymap, + highlightSpecialChars, + drawSelection, + rectangularSelection, + crosshairCursor +} from "@codemirror/view"; +import { + EditorState, + Compartment +} from "@codemirror/state"; +import { + defaultKeymap +} from "@codemirror/commands"; +import { + bracketMatching +} from "@codemirror/language"; +import { + search, + searchKeymap, + highlightSelectionMatches +} from "@codemirror/search"; + +import {statusBar} from "../utils/statusBar.mjs"; +import {htmlPlugin} from "../utils/htmlWidget.mjs"; +import {copyOverride} from "../utils/copyOverride.mjs"; +import {eolCodeToSeq, eolCodeToName, renderSpecialChar} from "../utils/editorUtils.mjs"; + + /** * Waiter to handle events related to the output */ @@ -25,10 +57,418 @@ class OutputWaiter { this.app = app; this.manager = manager; + this.outputTextEl = document.getElementById("output-text"); + // Object to handle output HTML state - used by htmlWidget extension + this.htmlOutput = { + html: "", + changed: false + }; + // Hold a copy of the currently displayed output so that we don't have to update it unnecessarily + this.currentOutputCache = null; + this.initEditor(); + this.outputs = {}; this.zipWorker = null; this.maxTabs = this.manager.tabs.calcMaxTabs(); this.tabTimeout = null; + this.eolState = 0; // 0 = unset, 1 = detected, 2 = manual + this.encodingState = 0; // 0 = unset, 1 = detected, 2 = manual + } + + /** + * Sets up the CodeMirror Editor + */ + initEditor() { + // Mutable extensions + this.outputEditorConf = { + eol: new Compartment, + lineWrapping: new Compartment, + drawSelection: new Compartment + }; + + const initialState = EditorState.create({ + doc: null, + extensions: [ + // Editor extensions + EditorState.readOnly.of(true), + highlightSpecialChars({ + render: renderSpecialChar, // Custom character renderer to handle special cases + addSpecialChars: /[\ue000-\uf8ff]/g // Add the Unicode Private Use Area which we use for some whitespace chars + }), + rectangularSelection(), + crosshairCursor(), + bracketMatching(), + highlightSelectionMatches(), + search({top: true}), + EditorState.allowMultipleSelections.of(true), + + // Custom extensions + statusBar({ + label: "Output", + timing: this.manager.timing, + tabNumGetter: function() { + return this.manager.tabs.getActiveTab("output"); + }.bind(this), + eolHandler: this.eolChange.bind(this), + chrEncHandler: this.chrEncChange.bind(this), + chrEncGetter: this.getChrEnc.bind(this), + getEncodingState: this.getEncodingState.bind(this), + getEOLState: this.getEOLState.bind(this), + htmlOutput: this.htmlOutput + }), + htmlPlugin(this.htmlOutput), + copyOverride(), + + // Mutable state + this.outputEditorConf.lineWrapping.of(EditorView.lineWrapping), + this.outputEditorConf.eol.of(EditorState.lineSeparator.of("\n")), + this.outputEditorConf.drawSelection.of(drawSelection()), + + // Keymap + keymap.of([ + ...defaultKeymap, + ...searchKeymap + ]), + + // Event listeners + EditorView.updateListener.of(e => { + if (e.selectionSet) + this.manager.highlighter.selectionChange("output", e); + if (e.docChanged || this.docChanging) { + this.docChanging = false; + this.toggleLoader(false); + } + }) + ] + }); + + if (this.outputEditorView) this.outputEditorView.destroy(); + this.outputEditorView = new EditorView({ + state: initialState, + parent: this.outputTextEl + }); + } + + /** + * Handler for EOL change events + * Sets the line separator + * @param {string} eol + * @param {boolean} [manual=false] + */ + async eolChange(eol, manual=false) { + const eolVal = eolCodeToSeq[eol]; + if (eolVal === undefined) return; + + this.eolState = manual ? 2 : this.eolState; + if (this.eolState < 2 && eolVal === this.getEOLSeq()) return; + + if (this.eolState === 1) { + // Alert + this.app.alert(`Output end of line separator has been detected and changed to ${eolCodeToName[eol]}`, 5000); + } + + const currentTabNum = this.manager.tabs.getActiveTab("output"); + if (currentTabNum >= 0) { + this.outputs[currentTabNum].eolSequence = eolVal; + } else { + throw new Error(`Cannot change output ${currentTabNum} EOL sequence to ${eolVal}`); + } + + // Update the EOL value + this.outputEditorView.dispatch({ + effects: this.outputEditorConf.eol.reconfigure(EditorState.lineSeparator.of(eolVal)) + }); + + // Reset the output so that lines are recalculated, preserving the old EOL values + await this.setOutput(this.currentOutputCache, true); + // Update the URL manually since we aren't firing a statechange event + this.app.updateURL(true); + } + + /** + * Getter for the output EOL sequence + * Prefer reading value from `this.outputs` since the editor may not have updated yet. + * @returns {string} + */ + getEOLSeq() { + const currentTabNum = this.manager.tabs.getActiveTab("output"); + if (currentTabNum < 0) { + return this.outputEditorConf.state?.lineBreak || "\n"; + } + return this.outputs[currentTabNum].eolSequence; + } + + /** + * Returns whether the output EOL sequence was set manually or has been detected automatically + * @returns {number} - 0 = unset, 1 = detected, 2 = manual + */ + getEOLState() { + return this.eolState; + } + + /** + * Handler for Chr Enc change events + * Sets the output character encoding + * @param {number} chrEncVal + * @param {boolean} [manual=false] + */ + async chrEncChange(chrEncVal, manual=false) { + if (typeof chrEncVal !== "number") return; + const currentEnc = this.getChrEnc(); + + const currentTabNum = this.manager.tabs.getActiveTab("output"); + if (currentTabNum >= 0) { + this.outputs[currentTabNum].encoding = chrEncVal; + } else { + throw new Error(`Cannot change output ${currentTabNum} chrEnc to ${chrEncVal}`); + } + + this.encodingState = manual ? 2 : this.encodingState; + + if (this.encodingState > 1) { + // Reset the output, forcing it to re-decode the data with the new character encoding + await this.setOutput(this.currentOutputCache, true); + // Update the URL manually since we aren't firing a statechange event + this.app.updateURL(true); + } else if (currentEnc !== chrEncVal) { + // Alert + this.app.alert(`Output character encoding has been detected and changed to ${CHR_ENC_SIMPLE_REVERSE_LOOKUP[chrEncVal] || "Raw Bytes"}`, 5000); + } + } + + /** + * Getter for the output character encoding + * @returns {number} + */ + getChrEnc() { + const currentTabNum = this.manager.tabs.getActiveTab("output"); + if (currentTabNum < 0) { + return 0; + } + return this.outputs[currentTabNum].encoding; + } + + /** + * Returns whether the output character encoding was set manually or has been detected automatically + * @returns {number} - 0 = unset, 1 = detected, 2 = manual + */ + getEncodingState() { + return this.encodingState; + } + + /** + * Sets word wrap on the output editor + * @param {boolean} wrap + */ + setWordWrap(wrap) { + this.outputEditorView.dispatch({ + effects: this.outputEditorConf.lineWrapping.reconfigure( + wrap ? EditorView.lineWrapping : [] + ) + }); + } + + /** + * Sets the value of the current output + * @param {string|ArrayBuffer} data + * @param {boolean} [force=false] + */ + async setOutput(data, force=false) { + // Don't do anything if the output hasn't changed + if (!force && data === this.currentOutputCache) { + this.manager.controls.hideStaleIndicator(); + this.toggleLoader(false); + return; + } + + this.currentOutputCache = data; + this.toggleLoader(true); + + // Remove class to #output-text to change display settings + this.outputTextEl.classList.remove("html-output"); + + // If data is an ArrayBuffer, convert to a string in the correct character encoding + const tabNum = this.manager.tabs.getActiveTab("output"); + this.manager.timing.recordTime("outputDecodingStart", tabNum); + if (data instanceof ArrayBuffer) { + await this.detectEncoding(data); + data = await this.bufferToStr(data); + } + this.manager.timing.recordTime("outputDecodingEnd", tabNum); + + // Turn drawSelection back on + this.outputEditorView.dispatch({ + effects: this.outputEditorConf.drawSelection.reconfigure( + drawSelection() + ) + }); + + // Ensure we're not exceeding the maximum line length + let wrap = this.app.options.wordWrap; + const lineLengthThreshold = 131072; // 128KB + if (data.length > lineLengthThreshold) { + const lines = data.split(this.getEOLSeq()); + const longest = lines.reduce((a, b) => + a > b.length ? a : b.length, 0 + ); + if (longest > lineLengthThreshold) { + // If we are exceeding the max line length, turn off word wrap + wrap = false; + } + } + + // If turning word wrap off, do it before we populate the editor for performance reasons + if (!wrap) this.setWordWrap(wrap); + + // Detect suitable EOL sequence + this.detectEOLSequence(data); + + // We use setTimeout here to delay the editor dispatch until the next event cycle, + // ensuring all async actions have completed before attempting to set the contents + // of the editor. This is mainly with the above call to setWordWrap() in mind. + setTimeout(() => { + this.docChanging = true; + // Insert data into editor, overwriting any previous contents + this.outputEditorView.dispatch({ + changes: { + from: 0, + to: this.outputEditorView.state.doc.length, + insert: data + } + }); + + // If turning word wrap on, do it after we populate the editor + if (wrap) + setTimeout(() => { + this.setWordWrap(wrap); + }); + }); + } + + /** + * Sets the value of the current output to a rendered HTML value + * @param {string} html + */ + async setHTMLOutput(html) { + this.htmlOutput.html = html; + this.htmlOutput.changed = true; + // This clears the text output, but also fires a View update which + // triggers the htmlWidget to render the HTML. We set the force flag + // to ensure the loader gets removed and HTML is rendered. + await this.setOutput("", true); + + // Turn off drawSelection + this.outputEditorView.dispatch({ + effects: this.outputEditorConf.drawSelection.reconfigure([]) + }); + + // Add class to #output-text to change display settings + this.outputTextEl.classList.add("html-output"); + + // Execute script sections + const outputHTML = document.getElementById("output-html"); + const scriptElements = outputHTML ? outputHTML.querySelectorAll("script") : []; + for (let i = 0; i < scriptElements.length; i++) { + try { + eval(scriptElements[i].innerHTML); // eslint-disable-line no-eval + } catch (err) { + log.error(err); + } + } + } + + /** + * Clears the HTML output + */ + clearHTMLOutput() { + this.htmlOutput.html = ""; + this.htmlOutput.changed = true; + // Fire a blank change to force the htmlWidget to update and remove any HTML + this.outputEditorView.dispatch({ + changes: { + from: 0, + insert: "" + } + }); + } + + /** + * Checks whether the EOL separator should be updated + * + * @param {string} data + */ + detectEOLSequence(data) { + // If EOL has been fixed, skip this. + if (this.eolState > 1) return; + // If data is too long, skip this. + if (data.length > 1000000) return; + + // Detect most likely EOL sequence + const eolCharCounts = { + "LF": data.count("\u000a"), + "VT": data.count("\u000b"), + "FF": data.count("\u000c"), + "CR": data.count("\u000d"), + "CRLF": data.count("\u000d\u000a"), + "NEL": data.count("\u0085"), + "LS": data.count("\u2028"), + "PS": data.count("\u2029") + }; + + // If all zero, leave alone + const total = Object.values(eolCharCounts).reduce((acc, curr) => { + return acc + curr; + }, 0); + if (total === 0) return; + + // Find most prevalent line ending sequence + const highest = Object.entries(eolCharCounts).reduce((acc, curr) => { + return curr[1] > acc[1] ? curr : acc; + }, ["LF", 0]); + let choice = highest[0]; + + // If CRLF not zero and more than half the highest alternative, choose CRLF + if ((eolCharCounts.CRLF * 2) > highest[1]) { + choice = "CRLF"; + } + + const eolVal = eolCodeToSeq[choice]; + if (eolVal === this.getEOLSeq()) return; + + // Setting automatically + this.eolState = 1; + this.eolChange(choice); + } + + /** + * Checks whether the character encoding should be updated. + * + * @param {ArrayBuffer} data + */ + async detectEncoding(data) { + // If encoding has been fixed, skip this. + if (this.encodingState > 1) return; + // If data is too long, skip this. + if (data.byteLength > 1000000) return; + + const enc = isUTF8(data); // 0 = not UTF8, 1 = ASCII, 2 = UTF8 + + switch (enc) { + case 0: // not UTF8 + // Set to Raw Bytes + this.encodingState = 1; + await this.chrEncChange(0, false); + break; + case 2: // UTF8 + // Set to UTF8 + this.encodingState = 1; + await this.chrEncChange(65001, false); + break; + case 1: // ASCII + default: + // Ignore + break; + } } /** @@ -38,7 +478,7 @@ class OutputWaiter { const numTabs = this.manager.tabs.calcMaxTabs(); if (numTabs !== this.maxTabs) { this.maxTabs = numTabs; - this.refreshTabs(this.manager.tabs.getActiveOutputTab(), "right"); + this.refreshTabs(this.manager.tabs.getActiveTab("output"), "right"); } } @@ -89,7 +529,9 @@ class OutputWaiter { error: null, status: "inactive", bakeId: -1, - progress: false + progress: false, + encoding: 0, + eolSequence: "\u000a" }; this.outputs[inputNum] = newOutput; @@ -116,7 +558,7 @@ class OutputWaiter { this.outputs[inputNum].data = data; - const tabItem = this.manager.tabs.getOutputTabItem(inputNum); + const tabItem = this.manager.tabs.getTabItem(inputNum, "output"); if (tabItem) tabItem.style.background = ""; if (set) this.set(inputNum); @@ -196,7 +638,7 @@ class OutputWaiter { this.outputs[inputNum].progress = progress; if (progress !== false) { - this.manager.tabs.updateOutputTabProgress(inputNum, progress, total); + this.manager.tabs.updateTabProgress(inputNum, progress, total, "output"); } } @@ -209,7 +651,7 @@ class OutputWaiter { removeOutput(inputNum) { if (!this.outputExists(inputNum)) return; - delete (this.outputs[inputNum]); + delete this.outputs[inputNum]; } /** @@ -218,8 +660,6 @@ class OutputWaiter { removeAllOutputs() { this.outputs = {}; - this.resetSwitch(); - const tabsList = document.getElementById("output-tabs"); const tabsListChildren = tabsList.children; @@ -231,25 +671,26 @@ class OutputWaiter { } /** - * Sets the output in the output textarea. + * Sets the output in the output pane. * * @param {number} inputNum */ async set(inputNum) { - if (inputNum !== this.manager.tabs.getActiveOutputTab() || + inputNum = parseInt(inputNum, 10); + if (inputNum !== this.manager.tabs.getActiveTab("output") || !this.outputExists(inputNum)) return; this.toggleLoader(true); return new Promise(async function(resolve, reject) { - const output = this.outputs[inputNum], - activeTab = this.manager.tabs.getActiveOutputTab(); - if (typeof inputNum !== "number") inputNum = parseInt(inputNum, 10); + const output = this.outputs[inputNum]; + this.manager.timing.recordTime("settingOutput", inputNum); - const outputText = document.getElementById("output-text"); - const outputHtml = document.getElementById("output-html"); - const outputFile = document.getElementById("output-file"); - const outputHighlighter = document.getElementById("output-highlighter"); - const inputHighlighter = document.getElementById("input-highlighter"); + // Update the EOL value + this.outputEditorView.dispatch({ + effects: this.outputEditorConf.eol.reconfigure( + EditorState.lineSeparator.of(output.eolSequence) + ) + }); // If pending or baking, show loader and status message // If error, style the tab and handle the error @@ -269,140 +710,55 @@ class OutputWaiter { this.manager.recipe.updateBreakpointIndicator(false); } - document.getElementById("show-file-overlay").style.display = "none"; - if (output.status === "pending" || output.status === "baking") { // show the loader and the status message if it's being shown // otherwise don't do anything document.querySelector("#output-loader .loading-msg").textContent = output.statusMessage; } else if (output.status === "error") { - // style the tab if it's being shown - this.toggleLoader(false); - outputText.style.display = "block"; - outputText.classList.remove("blur"); - outputHtml.style.display = "none"; - outputFile.style.display = "none"; - outputHighlighter.display = "none"; - inputHighlighter.display = "none"; + this.clearHTMLOutput(); if (output.error) { - outputText.value = output.error; + await this.setOutput(output.error); } else { - outputText.value = output.data.result; + await this.setOutput(output.data.result); } - outputHtml.innerHTML = ""; } else if (output.status === "baked" || output.status === "inactive") { document.querySelector("#output-loader .loading-msg").textContent = `Loading output ${inputNum}`; - this.closeFile(); - let scriptElements, lines, length; if (output.data === null) { - outputText.style.display = "block"; - outputHtml.style.display = "none"; - outputFile.style.display = "none"; - outputHighlighter.display = "block"; - inputHighlighter.display = "block"; - - outputText.value = ""; - outputHtml.innerHTML = ""; - - this.toggleLoader(false); + this.clearHTMLOutput(); + await this.setOutput(""); return; } switch (output.data.type) { case "html": - outputText.style.display = "none"; - outputHtml.style.display = "block"; - outputFile.style.display = "none"; - outputHighlighter.style.display = "none"; - inputHighlighter.style.display = "none"; - - outputText.value = ""; - outputHtml.innerHTML = output.data.result; - - // Execute script sections - scriptElements = outputHtml.querySelectorAll("script"); - for (let i = 0; i < scriptElements.length; i++) { - try { - eval(scriptElements[i].innerHTML); // eslint-disable-line no-eval - } catch (err) { - log.error(err); - } - } + await this.setHTMLOutput(output.data.result); break; case "ArrayBuffer": - outputText.style.display = "block"; - outputHtml.style.display = "none"; - outputHighlighter.display = "none"; - inputHighlighter.display = "none"; - - outputText.value = ""; - outputHtml.innerHTML = ""; - - length = output.data.result.byteLength; - this.setFile(await this.getDishBuffer(output.data.dish), activeTab); - break; case "string": default: - outputText.style.display = "block"; - outputHtml.style.display = "none"; - outputFile.style.display = "none"; - outputHighlighter.display = "block"; - inputHighlighter.display = "block"; - - outputText.value = Utils.printable(output.data.result, true); - outputHtml.innerHTML = ""; - - lines = output.data.result.count("\n") + 1; - length = output.data.result.length; + this.clearHTMLOutput(); + await this.setOutput(output.data.result); break; } - this.toggleLoader(false); + this.manager.timing.recordTime("complete", inputNum); - if (output.data.type === "html") { - const dishStr = await this.getDishStr(output.data.dish); - length = dishStr.length; - lines = dishStr.count("\n") + 1; - } + // Trigger an update so that the status bar recalculates timings + this.outputEditorView.dispatch({ + changes: { + from: 0, + to: 0 + } + }); - this.setOutputInfo(length, lines, output.data.duration); debounce(this.backgroundMagic, 50, "backgroundMagic", this, [])(); } }.bind(this)); } /** - * Shows file details - * - * @param {ArrayBuffer} buf - * @param {number} activeTab - */ - setFile(buf, activeTab) { - if (activeTab !== this.manager.tabs.getActiveOutputTab()) return; - // Display file overlay in output area with details - const fileOverlay = document.getElementById("output-file"), - fileSize = document.getElementById("output-file-size"), - outputText = document.getElementById("output-text"), - fileSlice = buf.slice(0, 4096); - - fileOverlay.style.display = "block"; - fileSize.textContent = buf.byteLength.toLocaleString() + " bytes"; - - outputText.classList.add("blur"); - outputText.value = Utils.printable(Utils.arrayBufferToStr(fileSlice)); - } - - /** - * Clears output file details - */ - closeFile() { - document.getElementById("output-file").style.display = "none"; - document.getElementById("output-text").classList.remove("blur"); - } - - /** - * Retrieves the dish as a string, returning the cached version if possible. + * Retrieves the dish as a string * * @param {Dish} dish * @returns {string} @@ -416,7 +772,7 @@ class OutputWaiter { } /** - * Retrieves the dish as an ArrayBuffer, returning the cached version if possible. + * Retrieves the dish as an ArrayBuffer * * @param {Dish} dish * @returns {ArrayBuffer} @@ -444,6 +800,23 @@ class OutputWaiter { }); } + /** + * Asks a worker to translate an ArrayBuffer into a certain character encoding + * + * @param {ArrrayBuffer} buffer + * @returns {string} + */ + async bufferToStr(buffer) { + const encoding = this.getChrEnc(); + + if (buffer.byteLength === 0) return ""; + return await new Promise(resolve => { + this.manager.worker.bufferToStr(buffer, encoding, r => { + resolve(r.value); + }); + }); + } + /** * Save bombe object then remove it from the DOM so that it does not cause performance issues. */ @@ -462,39 +835,41 @@ class OutputWaiter { * @param {boolean} value - If true, show the loader */ toggleLoader(value) { - clearTimeout(this.appendBombeTimeout); - clearTimeout(this.outputLoaderTimeout); - const outputLoader = document.getElementById("output-loader"), - outputElement = document.getElementById("output-text"), animation = document.getElementById("output-loader-animation"); if (value) { this.manager.controls.hideStaleIndicator(); + // Don't add the bombe if it's already there or scheduled to be loaded + if (animation.children.length === 0 && !this.appendBombeTimeout) { + // Start a timer to add the Bombe to the DOM just before we make it + // visible so that there is no stuttering + this.appendBombeTimeout = setTimeout(function() { + this.appendBombeTimeout = null; + animation.appendChild(this.bombeEl); + }.bind(this), 150); + } - // Don't add the bombe if it's already there! - if (animation.children.length > 0) return; + if (outputLoader.style.visibility !== "visible" && !this.outputLoaderTimeout) { + // Show the loading screen + this.outputLoaderTimeout = setTimeout(function() { + this.outputLoaderTimeout = null; + outputLoader.style.visibility = "visible"; + outputLoader.style.opacity = 1; + }, 200); + } + } else if (outputLoader.style.visibility !== "hidden" || this.appendBombeTimeout || this.outputLoaderTimeout) { + clearTimeout(this.appendBombeTimeout); + clearTimeout(this.outputLoaderTimeout); + this.appendBombeTimeout = null; + this.outputLoaderTimeout = null; - // Start a timer to add the Bombe to the DOM just before we make it - // visible so that there is no stuttering - this.appendBombeTimeout = setTimeout(function() { - animation.appendChild(this.bombeEl); - }.bind(this), 150); - - // Show the loading screen - this.outputLoaderTimeout = setTimeout(function() { - outputElement.disabled = true; - outputLoader.style.visibility = "visible"; - outputLoader.style.opacity = 1; - }, 200); - } else { // Remove the Bombe from the DOM to save resources this.outputLoaderTimeout = setTimeout(function () { - try { + this.outputLoaderTimeout = null; + if (animation.children.length > 0) animation.removeChild(this.bombeEl); - } catch (err) {} }.bind(this), 500); - outputElement.disabled = false; outputLoader.style.opacity = 0; outputLoader.style.visibility = "hidden"; } @@ -512,24 +887,33 @@ class OutputWaiter { * Handler for file download events. */ async downloadFile() { - const dish = this.getOutputDish(this.manager.tabs.getActiveOutputTab()); + const dish = this.getOutputDish(this.manager.tabs.getActiveTab("output")); if (dish === null) { this.app.alert("Could not find any output data to download. Has this output been baked?", 3000); return; } - const fileName = window.prompt("Please enter a filename: ", "download.dat"); + + const data = await dish.get(Dish.ARRAY_BUFFER); + let ext = ".dat"; + + // Detect file type automatically + const types = detectFileType(data); + if (types.length) { + ext = `.${types[0].extension.split(",", 1)[0]}`; + } + + const fileName = window.prompt("Please enter a filename: ", `download${ext}`); // Assume if the user clicks cancel they don't want to download if (fileName === null) return; - const data = await dish.get(Dish.ARRAY_BUFFER), - file = new File([data], fileName); - FileSaver.saveAs(file, fileName, false); + const file = new File([data], fileName); + FileSaver.saveAs(file, fileName, {autoBom: false}); } /** * Handler for save all click event - * Saves all outputs to a single archvie file + * Saves all outputs to a single archive file */ async saveAllClick() { const downloadButton = document.getElementById("save-all-to-file"); @@ -550,7 +934,6 @@ class OutputWaiter { } } - /** * Spawns a new ZipWorker and sends it the outputs so that they can * be zipped for download @@ -606,9 +989,16 @@ class OutputWaiter { log.debug("Creating ZipWorker"); this.zipWorker = new ZipWorker(); this.zipWorker.postMessage({ - outputs: this.outputs, - filename: fileName, - fileExtension: fileExt + action: "setLogLevel", + data: log.getLevel() + }); + this.zipWorker.postMessage({ + action: "zipFiles", + data: { + outputs: this.outputs, + filename: fileName, + fileExtension: fileExt + } }); this.zipWorker.addEventListener("message", this.handleZipWorkerMessage.bind(this)); } @@ -625,16 +1015,12 @@ class OutputWaiter { this.zipWorker = null; const downloadButton = document.getElementById("save-all-to-file"); - downloadButton.classList.remove("spin"); downloadButton.title = "Save all outputs to a zip file"; downloadButton.setAttribute("data-original-title", "Save all outputs to a zip file"); - downloadButton.firstElementChild.innerHTML = "archive"; - } - /** * Handle messages sent back by the ZipWorker */ @@ -652,7 +1038,7 @@ class OutputWaiter { } const file = new File([r.zippedFile], r.filename); - FileSaver.saveAs(file, r.filename, false); + FileSaver.saveAs(file, r.filename, {autoBom: false}); this.terminateZipWorker(); } @@ -667,9 +1053,9 @@ class OutputWaiter { const tabsWrapper = document.getElementById("output-tabs"); const numTabs = tabsWrapper.children.length; - if (!this.manager.tabs.getOutputTabItem(inputNum) && numTabs < this.maxTabs) { + if (!this.manager.tabs.getTabItem(inputNum, "output") && numTabs < this.maxTabs) { // Create a new tab element - const newTab = this.manager.tabs.createOutputTabElement(inputNum, changeTab); + const newTab = this.manager.tabs.createTabElement(inputNum, changeTab, "output"); tabsWrapper.appendChild(newTab); } else if (numTabs === this.maxTabs) { // Can't create a new tab @@ -691,14 +1077,11 @@ class OutputWaiter { */ changeTab(inputNum, changeInput = false) { if (!this.outputExists(inputNum)) return; - const currentNum = this.manager.tabs.getActiveOutputTab(); + const currentNum = this.manager.tabs.getActiveTab("output"); this.hideMagicButton(); - this.manager.highlighter.removeHighlights(); - getSelection().removeAllRanges(); - - if (!this.manager.tabs.changeOutputTab(inputNum)) { + if (!this.manager.tabs.changeTab(inputNum, "output")) { let direction = "right"; if (currentNum > inputNum) { direction = "left"; @@ -708,17 +1091,14 @@ class OutputWaiter { const tabsLeft = (newOutputs[0] !== this.getSmallestInputNum()); const tabsRight = (newOutputs[newOutputs.length - 1] !== this.getLargestInputNum()); - this.manager.tabs.refreshOutputTabs(newOutputs, inputNum, tabsLeft, tabsRight); + this.manager.tabs.refreshTabs(newOutputs, inputNum, tabsLeft, tabsRight, "output"); for (let i = 0; i < newOutputs.length; i++) { this.displayTabInfo(newOutputs[i]); } } - debounce(this.set, 50, "setOutput", this, [inputNum])(); - - document.getElementById("output-html").scroll(0, 0); - document.getElementById("output-text").scroll(0, 0); + this.set(inputNum); if (changeInput) { this.manager.input.changeTab(inputNum, false); @@ -732,6 +1112,7 @@ class OutputWaiter { */ changeTabClick(mouseEvent) { if (!mouseEvent.target) return; + const tabNum = mouseEvent.target.parentElement.getAttribute("inputNum"); if (tabNum) { this.changeTab(parseInt(tabNum, 10), this.app.options.syncTabs); @@ -801,7 +1182,7 @@ class OutputWaiter { * Handler for changing to the left tab */ changeTabLeft() { - const currentTab = this.manager.tabs.getActiveOutputTab(); + const currentTab = this.manager.tabs.getActiveTab("output"); this.changeTab(this.getPreviousInputNum(currentTab), this.app.options.syncTabs); } @@ -809,7 +1190,7 @@ class OutputWaiter { * Handler for changing to the right tab */ changeTabRight() { - const currentTab = this.manager.tabs.getActiveOutputTab(); + const currentTab = this.manager.tabs.getActiveTab("output"); this.changeTab(this.getNextInputNum(currentTab), this.app.options.syncTabs); } @@ -820,7 +1201,7 @@ class OutputWaiter { const min = this.getSmallestInputNum(), max = this.getLargestInputNum(); - let tabNum = window.prompt(`Enter tab number (${min} - ${max}):`, this.manager.tabs.getActiveOutputTab().toString()); + let tabNum = window.prompt(`Enter tab number (${min} - ${max}):`, this.manager.tabs.getActiveTab("output").toString()); if (tabNum === null) return; tabNum = parseInt(tabNum, 10); @@ -861,9 +1242,7 @@ class OutputWaiter { nums.push(newNum); } } - nums.sort(function(a, b) { - return a - b; - }); + nums.sort((a, b) => a - b); // Forces the sort function to treat a and b as numbers return nums; } @@ -939,7 +1318,7 @@ class OutputWaiter { removeTab(inputNum) { if (!this.outputExists(inputNum)) return; - const tabElement = this.manager.tabs.getOutputTabItem(inputNum); + const tabElement = this.manager.tabs.getTabItem(inputNum, "output"); this.removeOutput(inputNum); @@ -950,6 +1329,7 @@ class OutputWaiter { /** * Redraw the entire tab bar to remove any outdated tabs + * * @param {number} activeTab * @param {string} direction - Either "left" or "right" */ @@ -958,12 +1338,11 @@ class OutputWaiter { tabsLeft = (newNums[0] !== this.getSmallestInputNum() && newNums.length > 0), tabsRight = (newNums[newNums.length - 1] !== this.getLargestInputNum() && newNums.length > 0); - this.manager.tabs.refreshOutputTabs(newNums, activeTab, tabsLeft, tabsRight); + this.manager.tabs.refreshTabs(newNums, activeTab, tabsLeft, tabsRight, "output"); for (let i = 0; i < newNums.length; i++) { this.displayTabInfo(newNums[i]); } - } /** @@ -972,7 +1351,8 @@ class OutputWaiter { * @param {number} inputNum */ async displayTabInfo(inputNum) { - if (!this.outputExists(inputNum)) return; + // Don't display anything if there are no, or only one, tabs + if (!this.outputExists(inputNum) || Object.keys(this.outputs).length <= 1) return; const dish = this.getOutputDish(inputNum); let tabStr = ""; @@ -981,12 +1361,12 @@ class OutputWaiter { tabStr = await this.getDishTitle(this.getOutputDish(inputNum), 100); tabStr = tabStr.replace(/[\n\r]/g, ""); } - this.manager.tabs.updateOutputTabHeader(inputNum, tabStr); + this.manager.tabs.updateTabHeader(inputNum, tabStr, "output"); if (this.manager.worker.recipeConfig !== undefined) { - this.manager.tabs.updateOutputTabProgress(inputNum, this.outputs[inputNum].progress, this.manager.worker.recipeConfig.length); + this.manager.tabs.updateTabProgress(inputNum, this.outputs[inputNum]?.progress, this.manager.worker.recipeConfig.length, "output"); } - const tabItem = this.manager.tabs.getOutputTabItem(inputNum); + const tabItem = this.manager.tabs.getTabItem(inputNum, "output"); if (tabItem) { if (this.outputs[inputNum].status === "error") { tabItem.style.color = "#FF0000"; @@ -996,39 +1376,12 @@ class OutputWaiter { } } - /** - * Displays information about the output. - * - * @param {number} length - The length of the current output string - * @param {number} lines - The number of the lines in the current output string - * @param {number} duration - The length of time (ms) it took to generate the output - */ - setOutputInfo(length, lines, duration) { - if (!length) return; - let width = length.toString().length; - width = width < 4 ? 4 : width; - - const lengthStr = length.toString().padStart(width, " ").replace(/ /g, " "); - const timeStr = (duration.toString() + "ms").padStart(width, " ").replace(/ /g, " "); - - let msg = "time: " + timeStr + "
length: " + lengthStr; - - if (typeof lines === "number") { - const linesStr = lines.toString().padStart(width, " ").replace(/ /g, " "); - msg += "
lines: " + linesStr; - } - - document.getElementById("output-info").innerHTML = msg; - document.getElementById("input-selection-info").innerHTML = ""; - document.getElementById("output-selection-info").innerHTML = ""; - } - /** * Triggers the BackgroundWorker to attempt Magic on the current output. */ async backgroundMagic() { this.hideMagicButton(); - const dish = this.getOutputDish(this.manager.tabs.getActiveOutputTab()); + const dish = this.getOutputDish(this.manager.tabs.getActiveTab("output")); if (!this.app.options.autoMagic || dish === null) return; const buffer = await this.getDishBuffer(dish); const sample = buffer.slice(0, 1000) || ""; @@ -1105,92 +1458,6 @@ class OutputWaiter { magicButton.setAttribute("data-original-title", "Magic!"); } - - /** - * Handler for file slice display events. - */ - async displayFileSlice() { - document.querySelector("#output-loader .loading-msg").textContent = "Loading file slice..."; - this.toggleLoader(true); - const outputText = document.getElementById("output-text"), - outputHtml = document.getElementById("output-html"), - outputFile = document.getElementById("output-file"), - outputHighlighter = document.getElementById("output-highlighter"), - inputHighlighter = document.getElementById("input-highlighter"), - showFileOverlay = document.getElementById("show-file-overlay"), - sliceFromEl = document.getElementById("output-file-slice-from"), - sliceToEl = document.getElementById("output-file-slice-to"), - sliceFrom = parseInt(sliceFromEl.value, 10) * 1024, - sliceTo = parseInt(sliceToEl.value, 10) * 1024, - output = this.outputs[this.manager.tabs.getActiveOutputTab()].data; - - let str; - if (output.type === "ArrayBuffer") { - str = Utils.arrayBufferToStr(output.result.slice(sliceFrom, sliceTo)); - } else { - str = Utils.arrayBufferToStr(await this.getDishBuffer(output.dish).slice(sliceFrom, sliceTo)); - } - - outputText.classList.remove("blur"); - showFileOverlay.style.display = "block"; - outputText.value = Utils.printable(str, true); - - outputText.style.display = "block"; - outputHtml.style.display = "none"; - outputFile.style.display = "none"; - outputHighlighter.display = "block"; - inputHighlighter.display = "block"; - - this.toggleLoader(false); - } - - /** - * Handler for showing an entire file at user's discretion (even if it's way too big) - */ - async showAllFile() { - document.querySelector("#output-loader .loading-msg").textContent = "Loading entire file at user instruction. This may cause a crash..."; - this.toggleLoader(true); - const outputText = document.getElementById("output-text"), - outputHtml = document.getElementById("output-html"), - outputFile = document.getElementById("output-file"), - outputHighlighter = document.getElementById("output-highlighter"), - inputHighlighter = document.getElementById("input-highlighter"), - showFileOverlay = document.getElementById("show-file-overlay"), - output = this.outputs[this.manager.tabs.getActiveOutputTab()].data; - - let str; - if (output.type === "ArrayBuffer") { - str = Utils.arrayBufferToStr(output.result); - } else { - str = Utils.arrayBufferToStr(await this.getDishBuffer(output.dish)); - } - - outputText.classList.remove("blur"); - showFileOverlay.style.display = "none"; - outputText.value = Utils.printable(str, true); - - outputText.style.display = "block"; - outputHtml.style.display = "none"; - outputFile.style.display = "none"; - outputHighlighter.display = "block"; - inputHighlighter.display = "block"; - - this.toggleLoader(false); - } - - /** - * Handler for show file overlay events - * - * @param {Event} e - */ - showFileOverlayClick(e) { - const showFileOverlay = e.target; - - document.getElementById("output-text").classList.add("blur"); - showFileOverlay.style.display = "none"; - this.set(this.manager.tabs.getActiveOutputTab()); - } - /** * Handler for extract file events. * @@ -1214,58 +1481,20 @@ class OutputWaiter { * Copies the output to the clipboard */ async copyClick() { - const dish = this.getOutputDish(this.manager.tabs.getActiveOutputTab()); + const dish = this.getOutputDish(this.manager.tabs.getActiveTab("output")); if (dish === null) { this.app.alert("Could not find data to copy. Has this output been baked yet?", 3000); return; } - const output = await dish.get(Dish.STRING); + const output = await this.getDishStr(dish); + const self = this; - // Create invisible textarea to populate with the raw dish string (not the printable version that - // contains dots instead of the actual bytes) - const textarea = document.createElement("textarea"); - textarea.style.position = "fixed"; - textarea.style.top = 0; - textarea.style.left = 0; - textarea.style.width = 0; - textarea.style.height = 0; - textarea.style.border = "none"; - - textarea.value = output; - document.body.appendChild(textarea); - - let success = false; - try { - textarea.select(); - success = output && document.execCommand("copy"); - } catch (err) { - success = false; - } - - if (success) { - this.app.alert("Copied raw output successfully.", 2000); - } else { - this.app.alert("Sorry, the output could not be copied.", 3000); - } - - // Clean up - document.body.removeChild(textarea); - } - - /** - * Returns true if the output contains carriage returns - * - * @returns {boolean} - */ - async containsCR() { - const dish = this.getOutputDish(this.manager.tabs.getActiveOutputTab()); - if (dish === null) return; - - if (dish.type === Dish.STRING) { - const data = await dish.get(Dish.STRING); - return data.indexOf("\r") >= 0; - } + navigator.clipboard.writeText(output).then(function() { + self.app.alert("Copied raw output successfully.", 2000); + }, function(err) { + self.app.alert("Sorry, the output could not be copied.", 3000); + }); } /** @@ -1273,93 +1502,25 @@ class OutputWaiter { * Moves the current output into the input textarea. */ async switchClick() { - const activeTab = this.manager.tabs.getActiveOutputTab(); - const transferable = []; - + const activeTab = this.manager.tabs.getActiveTab("output"); const switchButton = document.getElementById("switch"); + switchButton.classList.add("spin"); switchButton.disabled = true; switchButton.firstElementChild.innerHTML = "autorenew"; $(switchButton).tooltip("hide"); - let active = await this.getDishBuffer(this.getOutputDish(activeTab)); + const activeData = await this.getDishBuffer(this.getOutputDish(activeTab)); - if (!this.outputExists(activeTab)) { - this.resetSwitchButton(); - return; + if (this.outputExists(activeTab)) { + this.manager.input.set(activeTab, { + type: "userinput", + buffer: activeData, + encoding: this.outputs[activeTab].encoding, + eolSequence: this.outputs[activeTab].eolSequence + }); } - if (this.outputs[activeTab].data.type === "string" && - active.byteLength <= this.app.options.ioDisplayThreshold * 1024) { - const dishString = await this.getDishStr(this.getOutputDish(activeTab)); - if (!await this.manager.input.preserveCarriageReturns(dishString)) { - active = dishString; - } - } else { - transferable.push(active); - } - - this.manager.input.inputWorker.postMessage({ - action: "inputSwitch", - data: { - inputNum: activeTab, - outputData: active - } - }, transferable); - } - - /** - * Handler for when the inputWorker has switched the inputs. - * Stores the old input - * - * @param {object} switchData - * @param {number} switchData.inputNum - * @param {string | object} switchData.data - * @param {ArrayBuffer} switchData.data.fileBuffer - * @param {number} switchData.data.size - * @param {string} switchData.data.type - * @param {string} switchData.data.name - */ - inputSwitch(switchData) { - this.switchOrigData = switchData; - document.getElementById("undo-switch").disabled = false; - - this.resetSwitchButton(); - - } - - /** - * Handler for undo switch click events. - * Removes the output from the input and replaces the input that was removed. - */ - undoSwitchClick() { - this.manager.input.updateInputObj(this.switchOrigData.inputNum, this.switchOrigData.data); - - this.manager.input.fileLoaded(this.switchOrigData.inputNum); - - this.resetSwitch(); - } - - /** - * Removes the switch data and resets the switch buttons - */ - resetSwitch() { - if (this.switchOrigData !== undefined) { - delete this.switchOrigData; - } - - const undoSwitch = document.getElementById("undo-switch"); - undoSwitch.disabled = true; - $(undoSwitch).tooltip("hide"); - - this.resetSwitchButton(); - } - - /** - * Resets the switch button to its usual state - */ - resetSwitchButton() { - const switchButton = document.getElementById("switch"); switchButton.classList.remove("spin"); switchButton.disabled = false; switchButton.firstElementChild.innerHTML = "open_in_browser"; @@ -1380,10 +1541,12 @@ class OutputWaiter { this.app.ioSplitter.collapse(0); $(el).attr("data-original-title", "Restore output pane"); + $(el).attr("aria-label", "Restore output pane"); el.querySelector("i").innerHTML = "fullscreen_exit"; } else { document.body.classList.remove("output-maximised"); $(el).attr("data-original-title", "Maximise output pane"); + $(el).attr("aria-label", "Maximise output pane"); el.querySelector("i").innerHTML = "fullscreen"; this.app.initialiseSplitter(false); this.app.resetLayout(); @@ -1509,6 +1672,18 @@ class OutputWaiter { $("#output-tab-modal").modal("hide"); this.changeTab(inputNum, this.app.options.syncTabs); } + + + /** + * Sets the console log level in the workers. + */ + setLogLevel() { + if (!this.zipWorker) return; + this.zipWorker.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); + } } export default OutputWaiter; diff --git a/src/web/waiters/RecipeWaiter.mjs b/src/web/waiters/RecipeWaiter.mjs index f4107e66..4272ef3b 100755 --- a/src/web/waiters/RecipeWaiter.mjs +++ b/src/web/waiters/RecipeWaiter.mjs @@ -7,6 +7,8 @@ import HTMLOperation from "../HTMLOperation.mjs"; import Sortable from "sortablejs"; import Utils from "../../core/Utils.mjs"; +import {escapeControlChars} from "../utils/editorUtils.mjs"; +import DOMPurify from "dompurify"; /** @@ -132,7 +134,7 @@ class RecipeWaiter { // Reinitialise the popover on the original element in the ops list because for some reason it // gets destroyed and recreated. If the clone isn't in the ops list, we use the original item instead. let enableOpsElement; - if (evt.clone.parentNode && evt.clone.parentNode.classList.contains("op-list")) { + if (evt.clone?.parentNode?.classList?.contains("op-list")) { enableOpsElement = evt.clone; } else { enableOpsElement = evt.item; @@ -162,13 +164,13 @@ class RecipeWaiter { e.stopPropagation(); e.preventDefault(); - if (e.target.className && e.target.className.indexOf("category-title") > -1) { + if (e.target?.className?.indexOf("category-title") > -1) { // Hovering over the a e.target.classList.add("favourites-hover"); - } else if (e.target.parentNode.className && e.target.parentNode.className.indexOf("category-title") > -1) { + } else if (e.target?.parentNode?.className?.indexOf("category-title") > -1) { // Hovering over the Edit button e.target.parentNode.classList.add("favourites-hover"); - } else if (e.target.parentNode.parentNode.className && e.target.parentNode.parentNode.className.indexOf("category-title") > -1) { + } else if (e.target?.parentNode?.parentNode?.className?.indexOf("category-title") > -1) { // Hovering over the image on the Edit button e.target.parentNode.parentNode.classList.add("favourites-hover"); } @@ -210,10 +212,49 @@ class RecipeWaiter { * @fires Manager#statechange */ ingChange(e) { - if (e && e.target && e.target.classList.contains("no-state-change")) return; + if (e && e?.target?.classList?.contains("no-state-change")) return; window.dispatchEvent(this.manager.statechange); } + /** + * Handler for hide-args click events. + * Updates the icon status. + * + * @fires Manager#statechange + * @param {event} e + */ + hideArgsClick(e) { + const icon = e.target; + + if (icon.getAttribute("hide-args") === "false") { + icon.setAttribute("hide-args", "true"); + icon.innerText = "keyboard_arrow_down"; + icon.classList.add("hide-args-selected"); + icon.parentNode.previousElementSibling.style.display = "none"; + } else { + icon.setAttribute("hide-args", "false"); + icon.innerText = "keyboard_arrow_up"; + icon.classList.remove("hide-args-selected"); + icon.parentNode.previousElementSibling.style.display = "grid"; + } + + const icons = Array.from(document.getElementsByClassName("hide-args-icon")); + if (icons.length > 1) { + // Check if ALL the icons are hidden/shown + const uniqueIcons = icons.map(function(item) { + return item.getAttribute("hide-args"); + }).unique(); + + const controlsIconStatus = document.getElementById("hide-icon").getAttribute("hide-args"); + + // If all icons are in the same state and the global icon isn't, fix it + if (uniqueIcons.length === 1 && icon.getAttribute("hide-args") !== controlsIconStatus) { + this.manager.controls.hideRecipeArgsClick(); + } + } + + window.dispatchEvent(this.manager.statechange); + } /** * Handler for disable click events. @@ -376,6 +417,8 @@ class RecipeWaiter { el.classList.add("flow-control-op"); } + $(el).find("[data-toggle='tooltip']").tooltip(); + // Disable auto-bake if this is a manual op if (op.manualBake && this.app.autoBake_) { this.manager.controls.setAutoBake(false); @@ -395,12 +438,12 @@ class RecipeWaiter { const item = document.createElement("li"); item.classList.add("operation"); - item.innerHTML = name; + const clean = DOMPurify.sanitize(name); + item.innerHTML = clean; + this.buildRecipeOperation(item); document.getElementById("rec-list").appendChild(item); - $(item).find("[data-toggle='tooltip']").tooltip(); - item.dispatchEvent(this.manager.operationadd); return item; } @@ -568,7 +611,7 @@ class RecipeWaiter { const registerList = []; for (let i = 0; i < registers.length; i++) { - registerList.push(`$R${numPrevRegisters + i} = ${Utils.escapeHtml(Utils.truncate(Utils.printable(registers[i]), 100))}`); + registerList.push(`$R${numPrevRegisters + i} = ${escapeControlChars(Utils.escapeHtml(Utils.truncate(registers[i], 100)))}`); } const registerListEl = `
${registerList.join("
")} @@ -584,42 +627,6 @@ class RecipeWaiter { adjustWidth() { const recList = document.getElementById("rec-list"); - if (!this.ingredientRuleID) { - this.ingredientRuleID = null; - this.ingredientChildRuleID = null; - - // Find relevant rules in the stylesheet - // try/catch for chrome 64+ CORS error on cssRules. - try { - for (const i in document.styleSheets[0].cssRules) { - if (document.styleSheets[0].cssRules[i].selectorText === ".ingredients") { - this.ingredientRuleID = i; - } - if (document.styleSheets[0].cssRules[i].selectorText === ".ingredients > div") { - this.ingredientChildRuleID = i; - } - } - } catch (e) { - // Do nothing. - } - } - - if (!this.ingredientRuleID || !this.ingredientChildRuleID) return; - - const ingredientRule = document.styleSheets[0].cssRules[this.ingredientRuleID]; - const ingredientChildRule = document.styleSheets[0].cssRules[this.ingredientChildRuleID]; - - if (recList.clientWidth < 450) { - ingredientRule.style.gridTemplateColumns = "auto auto"; - ingredientChildRule.style.gridColumn = "1 / span 2"; - } else if (recList.clientWidth < 620) { - ingredientRule.style.gridTemplateColumns = "auto auto auto"; - ingredientChildRule.style.gridColumn = "1 / span 3"; - } else { - ingredientRule.style.gridTemplateColumns = "auto auto auto auto"; - ingredientChildRule.style.gridColumn = "1 / span 4"; - } - // Hide Chef icon on Bake button if the page is compressed const bakeIcon = document.querySelector("#bake img"); @@ -635,7 +642,7 @@ class RecipeWaiter { const controlsContent = document.getElementById("controls-content"); const scale = (controls.clientWidth - 1) / controlsContent.scrollWidth; - controlsContent.style.transform = `translate(-50%, -50%) scale(${scale})`; + controlsContent.style.transform = `scale(${scale})`; } } diff --git a/src/web/waiters/SeasonalWaiter.mjs b/src/web/waiters/SeasonalWaiter.mjs index 8ad93452..c754dc8f 100755 --- a/src/web/waiters/SeasonalWaiter.mjs +++ b/src/web/waiters/SeasonalWaiter.mjs @@ -30,8 +30,7 @@ class SeasonalWaiter { window.addEventListener("keydown", this.konamiCodeListener.bind(this)); // CyberChef Challenge - // eslint-disable-next-line no-console - console.log("43 6f 6e 67 72 61 74 75 6c 61 74 69 6f 6e 73 2c 20 79 6f 75 20 68 61 76 65 20 63 6f 6d 70 6c 65 74 65 64 20 43 79 62 65 72 43 68 65 66 20 63 68 61 6c 6c 65 6e 67 65 20 23 31 21 0a 0a 54 68 69 73 20 63 68 61 6c 6c 65 6e 67 65 20 65 78 70 6c 6f 72 65 64 20 68 65 78 61 64 65 63 69 6d 61 6c 20 65 6e 63 6f 64 69 6e 67 2e 20 54 6f 20 6c 65 61 72 6e 20 6d 6f 72 65 2c 20 76 69 73 69 74 20 77 69 6b 69 70 65 64 69 61 2e 6f 72 67 2f 77 69 6b 69 2f 48 65 78 61 64 65 63 69 6d 61 6c 2e 0a 0a 54 68 65 20 63 6f 64 65 20 66 6f 72 20 74 68 69 73 20 63 68 61 6c 6c 65 6e 67 65 20 69 73 20 39 64 34 63 62 63 65 66 2d 62 65 35 32 2d 34 37 35 31 2d 61 32 62 32 2d 38 33 33 38 65 36 34 30 39 34 31 36 20 28 6b 65 65 70 20 74 68 69 73 20 70 72 69 76 61 74 65 29 2e 0a 0a 54 68 65 20 6e 65 78 74 20 63 68 61 6c 6c 65 6e 67 65 20 63 61 6e 20 62 65 20 66 6f 75 6e 64 20 61 74 20 68 74 74 70 73 3a 2f 2f 70 61 73 74 65 62 69 6e 2e 63 6f 6d 2f 47 53 6e 54 41 6d 6b 56 2e"); + log.info("43 6f 6e 67 72 61 74 75 6c 61 74 69 6f 6e 73 2c 20 79 6f 75 20 68 61 76 65 20 63 6f 6d 70 6c 65 74 65 64 20 43 79 62 65 72 43 68 65 66 20 63 68 61 6c 6c 65 6e 67 65 20 23 31 21 0a 0a 54 68 69 73 20 63 68 61 6c 6c 65 6e 67 65 20 65 78 70 6c 6f 72 65 64 20 68 65 78 61 64 65 63 69 6d 61 6c 20 65 6e 63 6f 64 69 6e 67 2e 20 54 6f 20 6c 65 61 72 6e 20 6d 6f 72 65 2c 20 76 69 73 69 74 20 77 69 6b 69 70 65 64 69 61 2e 6f 72 67 2f 77 69 6b 69 2f 48 65 78 61 64 65 63 69 6d 61 6c 2e 0a 0a 54 68 65 20 63 6f 64 65 20 66 6f 72 20 74 68 69 73 20 63 68 61 6c 6c 65 6e 67 65 20 69 73 20 39 64 34 63 62 63 65 66 2d 62 65 35 32 2d 34 37 35 31 2d 61 32 62 32 2d 38 33 33 38 65 36 34 30 39 34 31 36 20 28 6b 65 65 70 20 74 68 69 73 20 70 72 69 76 61 74 65 29 2e 0a 0a 54 68 65 20 6e 65 78 74 20 63 68 61 6c 6c 65 6e 67 65 20 63 61 6e 20 62 65 20 66 6f 75 6e 64 20 61 74 20 68 74 74 70 73 3a 2f 2f 70 61 73 74 65 62 69 6e 2e 63 6f 6d 2f 47 53 6e 54 41 6d 6b 56 2e"); } diff --git a/src/web/waiters/TabWaiter.mjs b/src/web/waiters/TabWaiter.mjs index 384b1ab7..a3361837 100644 --- a/src/web/waiters/TabWaiter.mjs +++ b/src/web/waiters/TabWaiter.mjs @@ -48,24 +48,6 @@ class TabWaiter { return -1; } - /** - * Gets the currently active input tab number - * - * @returns {number} - */ - getActiveInputTab() { - return this.getActiveTab("input"); - } - - /** - * Gets the currently active output tab number - * - * @returns {number} - */ - getActiveOutputTab() { - return this.getActiveTab("output"); - } - /** * Gets the li element for the tab of a given input number * @@ -83,26 +65,6 @@ class TabWaiter { return null; } - /** - * Gets the li element for an input tab of the given input number - * - * @param {inputNum} - The inputNum of the tab we're trying to get - * @returns {Element} - */ - getInputTabItem(inputNum) { - return this.getTabItem(inputNum, "input"); - } - - /** - * Gets the li element for an output tab of the given input number - * - * @param {number} inputNum - * @returns {Element} - */ - getOutputTabItem(inputNum) { - return this.getTabItem(inputNum, "output"); - } - /** * Gets a list of tab numbers for the currently displayed tabs * @@ -120,24 +82,6 @@ class TabWaiter { return nums; } - /** - * Gets a list of tab numbers for the currently displayed input tabs - * - * @returns {number[]} - */ - getInputTabList() { - return this.getTabList("input"); - } - - /** - * Gets a list of tab numbers for the currently displayed output tabs - * - * @returns {number[]} - */ - getOutputTabList() { - return this.getTabList("output"); - } - /** * Creates a new tab element for the tab bar * @@ -154,11 +98,8 @@ class TabWaiter { const newTabContent = document.createElement("div"); newTabContent.classList.add(`${io}-tab-content`); - newTabContent.innerText = `Tab ${inputNum.toString()}`; - newTabContent.addEventListener("wheel", this.manager[io].scrollTab.bind(this.manager[io]), {passive: false}); - newTab.appendChild(newTabContent); if (io === "input") { @@ -166,52 +107,24 @@ class TabWaiter { newTabButtonIcon = document.createElement("i"); newTabButton.type = "button"; newTabButton.className = "btn btn-primary bmd-btn-icon btn-close-tab"; - newTabButtonIcon.classList.add("material-icons"); newTabButtonIcon.innerText = "clear"; - newTabButton.appendChild(newTabButtonIcon); - newTabButton.addEventListener("click", this.manager.input.removeTabClick.bind(this.manager.input)); - newTab.appendChild(newTabButton); } return newTab; } - /** - * Creates a new tab element for the input tab bar - * - * @param {number} inputNum - The inputNum of the new input tab - * @param {boolean} [active=false] - If true, sets the tab to active - * @returns {Element} - */ - createInputTabElement(inputNum, active=false) { - return this.createTabElement(inputNum, active, "input"); - } - - /** - * Creates a new tab element for the output tab bar - * - * @param {number} inputNum - The inputNum of the new output tab - * @param {boolean} [active=false] - If true, sets the tab to active - * @returns {Element} - */ - createOutputTabElement(inputNum, active=false) { - return this.createTabElement(inputNum, active, "output"); - } - /** * Displays the tab bar for both the input and output */ showTabBar() { document.getElementById("input-tabs-wrapper").style.display = "block"; document.getElementById("output-tabs-wrapper").style.display = "block"; - document.getElementById("input-wrapper").classList.add("show-tabs"); document.getElementById("output-wrapper").classList.add("show-tabs"); - document.getElementById("save-all-to-file").style.display = "inline-block"; } @@ -221,10 +134,8 @@ class TabWaiter { hideTabBar() { document.getElementById("input-tabs-wrapper").style.display = "none"; document.getElementById("output-tabs-wrapper").style.display = "none"; - document.getElementById("input-wrapper").classList.remove("show-tabs"); document.getElementById("output-wrapper").classList.remove("show-tabs"); - document.getElementById("save-all-to-file").style.display = "none"; } @@ -271,30 +182,6 @@ class TabWaiter { } } - /** - * Refreshes the input tabs, and changes to activeTab - * - * @param {number[]} nums - The inputNums to be displayed as tabs - * @param {number} activeTab - The tab to change to - * @param {boolean} tabsLeft - True if there are input tabs to the left of the displayed tabs - * @param {boolean} tabsRight - True if there are input tabs to the right of the displayed tabs - */ - refreshInputTabs(nums, activeTab, tabsLeft, tabsRight) { - this.refreshTabs(nums, activeTab, tabsLeft, tabsRight, "input"); - } - - /** - * Refreshes the output tabs, and changes to activeTab - * - * @param {number[]} nums - The inputNums to be displayed as tabs - * @param {number} activeTab - The tab to change to - * @param {boolean} tabsLeft - True if there are output tabs to the left of the displayed tabs - * @param {boolean} tabsRight - True if there are output tabs to the right of the displayed tabs - */ - refreshOutputTabs(nums, activeTab, tabsLeft, tabsRight) { - this.refreshTabs(nums, activeTab, tabsLeft, tabsRight, "output"); - } - /** * Changes the active tab to a different tab * @@ -305,9 +192,6 @@ class TabWaiter { changeTab(inputNum, io) { const tabsList = document.getElementById(`${io}-tabs`); - this.manager.highlighter.removeHighlights(); - getSelection().removeAllRanges(); - let found = false; for (let i = 0; i < tabsList.children.length; i++) { const tabNum = parseInt(tabsList.children.item(i).getAttribute("inputNum"), 10); @@ -322,26 +206,6 @@ class TabWaiter { return found; } - /** - * Changes the active input tab to a different tab - * - * @param {number} inputNum - * @returns {boolean} - False if the tab is not currently being displayed - */ - changeInputTab(inputNum) { - return this.changeTab(inputNum, "input"); - } - - /** - * Changes the active output tab to a different tab - * - * @param {number} inputNum - * @returns {boolean} - False if the tab is not currently being displayed - */ - changeOutputTab(inputNum) { - return this.changeTab(inputNum, "output"); - } - /** * Updates the tab header to display a preview of the tab contents * @@ -361,26 +225,6 @@ class TabWaiter { tab.firstElementChild.innerText = headerData; } - /** - * Updates the input tab header to display a preview of the tab contents - * - * @param {number} inputNum - The inputNum of the tab to update the header of - * @param {string} data - The data to display in the tab header - */ - updateInputTabHeader(inputNum, data) { - this.updateTabHeader(inputNum, data, "input"); - } - - /** - * Updates the output tab header to display a preview of the tab contents - * - * @param {number} inputNum - The inputNum of the tab to update the header of - * @param {string} data - The data to display in the tab header - */ - updateOutputTabHeader(inputNum, data) { - this.updateTabHeader(inputNum, data, "output"); - } - /** * Updates the tab background to display the progress of the current tab * @@ -401,28 +245,6 @@ class TabWaiter { } } - /** - * Updates the input tab background to display its progress - * - * @param {number} inputNum - * @param {number} progress - * @param {number} total - */ - updateInputTabProgress(inputNum, progress, total) { - this.updateTabProgress(inputNum, progress, total, "input"); - } - - /** - * Updates the output tab background to display its progress - * - * @param {number} inputNum - * @param {number} progress - * @param {number} total - */ - updateOutputTabProgress(inputNum, progress, total) { - this.updateTabProgress(inputNum, progress, total, "output"); - } - } export default TabWaiter; diff --git a/src/web/waiters/TimingWaiter.mjs b/src/web/waiters/TimingWaiter.mjs new file mode 100644 index 00000000..88f281bb --- /dev/null +++ b/src/web/waiters/TimingWaiter.mjs @@ -0,0 +1,182 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2023 + * @license Apache-2.0 + */ + +/** + * Waiter to handle timing of the baking process. + */ +class TimingWaiter { + + /** + * TimingWaiter constructor. + * + * @param {App} app - The main view object for CyberChef. + * @param {Manager} manager - The CyberChef event manager. + */ + constructor(app, manager) { + this.app = app; + this.manager = manager; + + this.inputs = {}; + /* + Inputs example: + "1": { + "inputEncodingStart": 0, + "inputEncodingEnd": 0, + "trigger": 0 + "chefWorkerTasked": 0, + "bakeComplete": 0, + "bakeDuration": 0, + "settingOutput": 0, + "outputDecodingStart": 0, + "outputDecodingEnd": 0, + "complete": 0 + } + */ + } + + + /** + * Record the time for an input + * + * @param {string} event + * @param {number} inputNum + * @param {number} value + */ + recordTime(event, inputNum, value=Date.now()) { + inputNum = inputNum.toString(); + if (!Object.keys(this.inputs).includes(inputNum)) { + this.inputs[inputNum] = {}; + } + log.debug(`Recording ${event} for input ${inputNum}`); + this.inputs[inputNum][event] = value; + } + + /** + * The duration of the main stages of a bake + * + * @param {number} inputNum + * @returns {number} + */ + duration(inputNum) { + const input = this.inputs[inputNum.toString()]; + + // If this input has not been encoded yet, we cannot calculate a time + if (!input || + !input.trigger || + !input.inputEncodingEnd || + !input.inputEncodingStart) + return 0; + + // input encoding can happen before a bake is triggered, so it is calculated separately + const inputEncodingTotal = input.inputEncodingEnd - input.inputEncodingStart; + + let total = 0, outputDecodingTotal = 0; + + if (input.bakeComplete && input.bakeComplete > input.trigger) + total = input.bakeComplete - input.trigger; + + if (input.settingOutput && input.settingOutput > input.trigger) + total = input.settingOutput - input.trigger; + + if (input.outputDecodingStart && (input.outputDecodingStart > input.trigger) && + input.outputDecodingEnd && (input.outputDecodingEnd > input.trigger)) { + total = input.outputDecodingEnd - input.trigger; + outputDecodingTotal = input.outputDecodingEnd - input.outputDecodingStart; + } + + if (input.complete && input.complete > input.trigger) + total = inputEncodingTotal + input.bakeDuration + outputDecodingTotal; + + return total; + } + + /** + * The total time for a completed bake + * + * @param {number} inputNum + * @returns {number} + */ + overallDuration(inputNum) { + const input = this.inputs[inputNum.toString()]; + + // If this input has not been encoded yet, we cannot calculate a time + if (!input || + !input.trigger || + !input.inputEncodingEnd || + !input.inputEncodingStart) + return 0; + + // input encoding can happen before a bake is triggered, so it is calculated separately + const inputEncodingTotal = input.inputEncodingEnd - input.inputEncodingStart; + + let total = 0; + if (input.bakeComplete && input.bakeComplete > input.trigger) + total = input.bakeComplete - input.trigger; + + if (input.settingOutput && input.settingOutput > input.trigger) + total = input.settingOutput - input.trigger; + + if (input.outputDecodingStart && input.outputDecodingStart > input.trigger) + total = input.outputDecodingStart - input.trigger; + + if (input.outputDecodingEnd && input.outputDecodingEnd > input.trigger) + total = input.outputDecodingEnd - input.trigger; + + if (input.complete && input.complete > input.trigger) + total = input.complete - input.trigger; + + return total + inputEncodingTotal; + } + + /** + * Prints out the time between stages + * + * @param {number} inputNum + * @returns {string} + */ + printStages(inputNum) { + const input = this.inputs[inputNum.toString()]; + if (!input || !input.trigger) return ""; + + const total = this.overallDuration(inputNum), + inputEncoding = input.inputEncodingEnd - input.inputEncodingStart, + outputDecoding = input.outputDecodingEnd - input.outputDecodingStart, + overhead = total - inputEncoding - outputDecoding - input.bakeDuration; + + return `Input encoding: ${inputEncoding}ms +Recipe duration: ${input.bakeDuration}ms +Output decoding: ${outputDecoding}ms +Threading overhead: ${overhead}ms`; + } + + /** + * Logs every interval + * + * @param {number} inputNum + */ + logAllTimes(inputNum) { + const input = this.inputs[inputNum.toString()]; + if (!input || !input.trigger) return; + + try { + log.debug(`Trigger: ${input.trigger} +inputEncodingStart: ${input.inputEncodingStart} | ${input.inputEncodingStart - input.trigger}ms since trigger +inputEncodingEnd: ${input.inputEncodingEnd} | ${input.inputEncodingEnd - input.inputEncodingStart}ms input encoding time +chefWorkerTasked: ${input.chefWorkerTasked} | ${input.chefWorkerTasked - input.trigger}ms since trigger +bakeDuration: | ${input.bakeDuration}ms duration in worker +bakeComplete: ${input.bakeComplete} | ${input.bakeComplete - input.chefWorkerTasked}ms since worker tasked +settingOutput: ${input.settingOutput} | ${input.settingOutput - input.bakeComplete}ms since worker finished +outputDecodingStart: ${input.outputDecodingStart} | ${input.outputDecodingStart - input.settingOutput}ms since output set +outputDecodingEnd: ${input.outputDecodingEnd} | ${input.outputDecodingEnd - input.outputDecodingStart}ms output encoding time +complete: ${input.complete} | ${input.complete - input.outputDecodingEnd}ms since output decoded +Total: | ${input.complete - input.trigger}ms since trigger`); + } catch (err) {} + + } + +} + +export default TimingWaiter; diff --git a/src/web/waiters/WorkerWaiter.mjs b/src/web/waiters/WorkerWaiter.mjs index 7fcaa509..296aa956 100644 --- a/src/web/waiters/WorkerWaiter.mjs +++ b/src/web/waiters/WorkerWaiter.mjs @@ -72,6 +72,10 @@ class WorkerWaiter { this.dishWorker.worker = new DishWorker(); this.dishWorker.worker.addEventListener("message", this.handleDishMessage.bind(this)); + this.dishWorker.worker.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); if (this.dishWorkerQueue.length > 0) { this.postDishMessage(this.dishWorkerQueue.splice(0, 1)[0]); @@ -89,22 +93,27 @@ class WorkerWaiter { return -1; } - log.debug("Adding new ChefWorker"); + log.debug(`Adding new ChefWorker (${this.chefWorkers.length + 1}/${this.maxWorkers})`); // Create a new ChefWorker and send it the docURL const newWorker = new ChefWorker(); newWorker.addEventListener("message", this.handleChefMessage.bind(this)); + newWorker.postMessage({ + action: "setLogPrefix", + data: "ChefWorker" + }); + newWorker.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); + let docURL = document.location.href.split(/[#?]/)[0]; const index = docURL.lastIndexOf("/"); if (index > 0) { docURL = docURL.substring(0, index); } - newWorker.postMessage({"action": "docURL", "data": docURL}); - newWorker.postMessage({ - action: "setLogLevel", - data: log.getLevel() - }); + // Store the worker, whether or not it's active, and the inputNum as an object const newWorkerObj = { @@ -177,7 +186,7 @@ class WorkerWaiter { handleChefMessage(e) { const r = e.data; let inputNum = 0; - log.debug(`Receiving ${r.action} from ChefWorker.`); + log.debug(`Receiving '${r.action}' from ChefWorker.`); if (Object.prototype.hasOwnProperty.call(r.data, "inputNum")) { inputNum = r.data.inputNum; @@ -188,6 +197,8 @@ class WorkerWaiter { switch (r.action) { case "bakeComplete": log.debug(`Bake ${inputNum} complete.`); + this.manager.timing.recordTime("bakeComplete", inputNum); + this.manager.timing.recordTime("bakeDuration", inputNum, r.data.duration); if (r.data.error) { this.app.handleError(r.data.error); @@ -217,7 +228,7 @@ class WorkerWaiter { break; case "workerLoaded": this.app.workerLoaded = true; - log.debug("ChefWorker loaded."); + log.debug("ChefWorker loaded"); if (!this.loaded) { this.app.loaded(); this.loaded = true; @@ -266,7 +277,7 @@ class WorkerWaiter { if (progress !== false) { this.manager.output.updateOutputStatus("error", inputNum); - if (inputNum === this.manager.tabs.getActiveInputTab()) { + if (inputNum === this.manager.tabs.getActiveTab("input")) { this.manager.recipe.updateBreakpointIndicator(progress); } @@ -311,40 +322,68 @@ class WorkerWaiter { }; } + /** + * Cancels the current bake making it possible to autobake again + */ + cancelBakeForAutoBake() { + if (this.totalOutputs > 1) { + this.cancelBake(); + } else { + // In this case the UI changes can be skipped + + for (let i = this.chefWorkers.length - 1; i >= 0; i--) { + if (this.chefWorkers[i].active) { + this.removeChefWorker(this.chefWorkers[i]); + } + } + + this.inputs = []; + this.inputNums = []; + this.totalOutputs = 0; + this.loadingOutputs = 0; + } + } + /** * Cancels the current bake by terminating and removing all ChefWorkers * * @param {boolean} [silent=false] - If true, don't set the output - * @param {boolean} killAll - If true, kills all chefWorkers regardless of status + * @param {boolean} [killAll=false] - If true, kills all chefWorkers regardless of status */ - cancelBake(silent, killAll) { + cancelBake(silent=false, killAll=false) { + const deactiveOutputs = new Set(); + for (let i = this.chefWorkers.length - 1; i >= 0; i--) { if (this.chefWorkers[i].active || killAll) { const inputNum = this.chefWorkers[i].inputNum; this.removeChefWorker(this.chefWorkers[i]); - this.manager.output.updateOutputStatus("inactive", inputNum); + deactiveOutputs.add(inputNum); } } this.setBakingStatus(false); - for (let i = 0; i < this.inputs.length; i++) { - this.manager.output.updateOutputStatus("inactive", this.inputs[i].inputNum); - } + this.inputs.forEach(input => { + deactiveOutputs.add(input.inputNum); + }); - for (let i = 0; i < this.inputNums.length; i++) { - this.manager.output.updateOutputStatus("inactive", this.inputNums[i]); - } + this.inputNums.forEach(inputNum => { + deactiveOutputs.add(inputNum); + }); - const tabList = this.manager.tabs.getOutputTabList(); - for (let i = 0; i < tabList.length; i++) { - this.manager.tabs.getOutputTabItem(tabList[i]).style.background = ""; - } + deactiveOutputs.forEach(num => { + this.manager.output.updateOutputStatus("inactive", num); + }); + + const tabList = this.manager.tabs.getTabList("output"); + tabList.forEach(tab => { + this.manager.tabs.getTabItem(tab, "output").style.background = ""; + }); this.inputs = []; this.inputNums = []; this.totalOutputs = 0; this.loadingOutputs = 0; - if (!silent) this.manager.output.set(this.manager.tabs.getActiveOutputTab()); + if (!silent) this.manager.output.set(this.manager.tabs.getActiveTab("output")); } /** @@ -455,6 +494,7 @@ class WorkerWaiter { if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) { transferable = [input]; } + this.manager.timing.recordTime("chefWorkerTasked", nextInput.inputNum); this.chefWorkers[workerIdx].worker.postMessage({ action: "bake", data: { @@ -550,10 +590,12 @@ class WorkerWaiter { * @param {boolean} inputData.step - If true, only execute the next operation in the recipe * @param {number} inputData.progress - The current progress through the recipe. Used when stepping */ - async bakeAllInputs(inputData) { + async bakeInputs(inputData) { + log.debug(`Baking input list [${inputData.nums.join(",")}]`); + return await new Promise(resolve => { if (this.app.baking) return; - const inputNums = inputData.nums; + const inputNums = inputData.nums.filter(n => n > 0); const step = inputData.step; // Use cancelBake to clear out the inputs @@ -586,6 +628,7 @@ class WorkerWaiter { numBakes = this.inputNums.length; } for (let i = 0; i < numBakes; i++) { + this.manager.timing.recordTime("trigger", this.inputNums[0]); this.manager.input.inputWorker.postMessage({ action: "bakeNext", data: { @@ -595,6 +638,7 @@ class WorkerWaiter { }); this.loadingOutputs++; } + if (numBakes === 0) this.bakingComplete(); }); } @@ -626,7 +670,7 @@ class WorkerWaiter { */ handleDishMessage(e) { const r = e.data; - log.debug(`Receiving ${r.action} from DishWorker`); + log.debug(`Receiving '${r.action}' from DishWorker`); switch (r.action) { case "dishReturned": @@ -645,7 +689,7 @@ class WorkerWaiter { } /** - * Asks the ChefWorker to return the dish as the specified type + * Asks the DishWorker to return the dish as the specified type * * @param {Dish} dish * @param {string} type @@ -653,10 +697,9 @@ class WorkerWaiter { */ getDishAs(dish, type, callback) { const id = this.callbackID++; - this.callbacks[id] = callback; - if (this.dishWorker.worker === null) this.setupDishWorker(); + this.postDishMessage({ action: "getDishAs", data: { @@ -668,7 +711,7 @@ class WorkerWaiter { } /** - * Asks the ChefWorker to get the title of the dish + * Asks the DishWorker to get the title of the dish * * @param {Dish} dish * @param {number} maxLength @@ -677,9 +720,7 @@ class WorkerWaiter { */ getDishTitle(dish, maxLength, callback) { const id = this.callbackID++; - this.callbacks[id] = callback; - if (this.dishWorker.worker === null) this.setupDishWorker(); this.postDishMessage({ @@ -692,6 +733,29 @@ class WorkerWaiter { }); } + /** + * Asks the DishWorker to translate a buffer into a specific character encoding + * + * @param {ArrayBuffer} buffer + * @param {number} encoding + * @param {Function} callback + * @returns {string} + */ + bufferToStr(buffer, encoding, callback) { + const id = this.callbackID++; + this.callbacks[id] = callback; + if (this.dishWorker.worker === null) this.setupDishWorker(); + + this.postDishMessage({ + action: "bufferToStr", + data: { + buffer: buffer, + encoding: encoding, + id: id + } + }); + } + /** * Queues a message to be sent to the dishWorker * @@ -729,12 +793,18 @@ class WorkerWaiter { * Sets the console log level in the workers. */ setLogLevel() { - for (let i = 0; i < this.chefWorkers.length; i++) { - this.chefWorkers[i].worker.postMessage({ + this.chefWorkers.forEach(cw => { + cw.worker.postMessage({ action: "setLogLevel", data: log.getLevel() }); - } + }); + + if (!this.dishWorker.worker) return; + this.dishWorker.worker.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); } /** @@ -794,7 +864,7 @@ class WorkerWaiter { * * @param {Object[]} recipeConfig * @param {string} direction - * @param {Object} pos - The position object for the highlight. + * @param {Object[]} pos - The position object for the highlight. * @param {number} pos.start - The start offset. * @param {number} pos.end - The end offset. */ diff --git a/src/web/workers/DishWorker.mjs b/src/web/workers/DishWorker.mjs index a171fdad..662f3ffc 100644 --- a/src/web/workers/DishWorker.mjs +++ b/src/web/workers/DishWorker.mjs @@ -7,11 +7,21 @@ */ import Dish from "../../core/Dish.mjs"; +import DishError from "../../core/errors/DishError.mjs"; +import { CHR_ENC_SIMPLE_REVERSE_LOOKUP } from "../../core/lib/ChrEnc.mjs"; +import Utils from "../../core/Utils.mjs"; +import cptable from "codepage"; +import loglevelMessagePrefix from "loglevel-message-prefix"; + +loglevelMessagePrefix(log, { + prefixes: [], + staticPrefixes: ["DishWorker"] +}); self.addEventListener("message", function(e) { // Handle message from the main thread const r = e.data; - log.debug(`DishWorker receiving command '${r.action}'`); + log.debug(`Receiving command '${r.action}'`); switch (r.action) { case "getDishAs": @@ -20,8 +30,14 @@ self.addEventListener("message", function(e) { case "getDishTitle": getDishTitle(r.data); break; + case "bufferToStr": + bufferToStr(r.data); + break; + case "setLogLevel": + log.setLevel(r.data, false); + break; default: - log.error(`DishWorker sent invalid action: '${r.action}'`); + log.error(`Unknown action: '${r.action}'`); } }); @@ -67,3 +83,32 @@ async function getDishTitle(data) { } }); } + +/** + * Translates a buffer to a string using a specified encoding + * + * @param {object} data + * @param {ArrayBuffer} data.buffer + * @param {number} data.id + * @param {number} data.encoding + */ +async function bufferToStr(data) { + let str; + if (data.encoding === 0) { + str = Utils.arrayBufferToStr(data.buffer); + } else { + try { + str = cptable.utils.decode(data.encoding, new Uint8Array(data.buffer)); + } catch (err) { + str = new DishError(`Error decoding buffer with encoding ${CHR_ENC_SIMPLE_REVERSE_LOOKUP[data.encoding]}: ${err.message}`).toString(); + } + } + + self.postMessage({ + action: "dishReturned", + data: { + value: str, + id: data.id + } + }); +} diff --git a/src/web/workers/InputWorker.mjs b/src/web/workers/InputWorker.mjs index 9912995b..d687fc9f 100644 --- a/src/web/workers/InputWorker.mjs +++ b/src/web/workers/InputWorker.mjs @@ -3,21 +3,43 @@ * Handles storage, modification and retrieval of the inputs. * * @author j433866 [j433866@gmail.com] + * @author n1474335 [n1474335@gmail.com] * @copyright Crown Copyright 2019 * @license Apache-2.0 */ import Utils from "../../core/Utils.mjs"; -import {detectFileType} from "../../core/lib/FileType.mjs"; +import loglevelMessagePrefix from "loglevel-message-prefix"; + +loglevelMessagePrefix(log, { + prefixes: [], + staticPrefixes: ["InputWorker"] +}); // Default max values // These will be correctly calculated automatically self.maxWorkers = 4; self.maxTabs = 1; -self.pendingFiles = []; +/** + * Dictionary of inputs keyed on the inputNum + * Each entry is an object with the following type: + * @typedef {Object} Input + * @property {string} type + * @property {ArrayBuffer} buffer + * @property {string} stringSample + * @property {Object} file + * @property {string} file.name + * @property {number} file.size + * @property {string} file.type + * @property {string} status + * @property {number} progress + * @property {number} encoding + * @property {string} eolSequence + */ self.inputs = {}; self.loaderWorkers = []; +self.pendingFiles = []; self.currentInputNum = 1; self.numInputs = 0; self.pendingInputs = 0; @@ -35,7 +57,7 @@ self.addEventListener("message", function(e) { return; } - log.debug(`Receiving ${r.action} from InputWaiter.`); + log.debug(`Receiving command '${r.action}'`); switch (r.action) { case "loadUIFiles": @@ -53,9 +75,6 @@ self.addEventListener("message", function(e) { case "updateInputValue": self.updateInputValue(r.data); break; - case "updateInputObj": - self.updateInputObj(r.data); - break; case "updateInputProgress": self.updateInputProgress(r.data); break; @@ -75,7 +94,7 @@ self.addEventListener("message", function(e) { log.setLevel(r.data, false); break; case "addInput": - self.addInput(r.data, "string"); + self.addInput(r.data, "userinput"); break; case "refreshTabs": self.refreshTabs(r.data.inputNum, r.data.direction); @@ -98,9 +117,6 @@ self.addEventListener("message", function(e) { case "loaderWorkerMessage": self.handleLoaderMessage(r.data); break; - case "inputSwitch": - self.inputSwitch(r.data); - break; case "updateTabHeader": self.updateTabHeader(r.data); break; @@ -155,10 +171,10 @@ self.getLoadProgress = function(inputNum) { * whole recipe */ self.autoBake = function(inputNum, progress, step=false) { - const input = self.getInputObj(inputNum); + const input = self.inputs[inputNum]; if (input) { self.postMessage({ - action: "bakeAllInputs", + action: "bakeInputs", data: { nums: [parseInt(inputNum, 10)], step: step, @@ -173,16 +189,14 @@ self.autoBake = function(inputNum, progress, step=false) { * Sends a list of inputNums to the workerwaiter */ self.bakeAllInputs = function() { - const inputNums = Object.keys(self.inputs), - nums = []; + const inputNums = Object.keys(self.inputs); + + const nums = inputNums + .filter(n => self.inputs[n].status === "loaded") + .map(n => parseInt(n, 10)); - for (let i = 0; i < inputNums.length; i++) { - if (self.inputs[inputNums[i]].status === "loaded") { - nums.push(parseInt(inputNums[i], 10)); - } - } self.postMessage({ - action: "bakeAllInputs", + action: "bakeInputs", data: { nums: nums, step: false, @@ -198,7 +212,7 @@ self.bakeAllInputs = function() { * @param {number} bakeId */ self.bakeInput = function(inputNum, bakeId) { - const inputObj = self.getInputObj(inputNum); + const inputObj = self.inputs[inputNum]; if (inputObj === null || inputObj === undefined || inputObj.status !== "loaded") { @@ -213,46 +227,16 @@ self.bakeInput = function(inputNum, bakeId) { return; } - let inputData = inputObj.data; - if (typeof inputData !== "string") inputData = inputData.fileBuffer; - self.postMessage({ action: "queueInput", data: { - input: inputData, + input: inputObj.buffer, inputNum: inputNum, bakeId: bakeId } }); }; -/** - * Gets the stored object for a specific inputNum - * - * @param {number} inputNum - The input we want to get the object for - * @returns {object} - */ -self.getInputObj = function(inputNum) { - return self.inputs[inputNum]; -}; - -/** - * Gets the stored value for a specific inputNum. - * - * @param {number} inputNum - The input we want to get the value of - * @returns {string | ArrayBuffer} - */ -self.getInputValue = function(inputNum) { - if (self.inputs[inputNum]) { - if (typeof self.inputs[inputNum].data === "string") { - return self.inputs[inputNum].data; - } else { - return self.inputs[inputNum].data.fileBuffer; - } - } - return ""; -}; - /** * Gets the stored value or object for a specific inputNum and sends it to the inputWaiter. * @@ -262,12 +246,11 @@ self.getInputValue = function(inputNum) { * @param {number} inputData.id - The callback ID for the callback to run when returned to the inputWaiter */ self.getInput = function(inputData) { - const inputNum = inputData.inputNum, - data = (inputData.getObj) ? self.getInputObj(inputNum) : self.getInputValue(inputNum); + const input = self.inputs[inputData.inputNum]; self.postMessage({ action: "getInput", data: { - data: data, + data: inputData.getObj ? input : input.buffer, id: inputData.id } }); @@ -301,8 +284,8 @@ self.getInputNums = function(id) { * @returns {number | string} - Returns "error" if there was a load error */ self.getInputProgress = function(inputNum) { - const inputObj = self.getInputObj(inputNum); - if (inputObj === undefined || inputObj === null) return; + const inputObj = self.inputs[inputNum]; + if (!inputObj) return; if (inputObj.status === "error") { return "error"; } @@ -419,19 +402,17 @@ self.getNearbyNums = function(inputNum, direction) { * @param {number} inputNum - The inputNum of the tab header */ self.updateTabHeader = function(inputNum) { - const input = self.getInputObj(inputNum); - if (input === null || input === undefined) return; - let inputData = input.data; - if (typeof inputData !== "string") { - inputData = input.data.name; - } - inputData = inputData.replace(/[\n\r]/g, ""); + const input = self.inputs[inputNum]; + if (!input) return; + + let header = input.type === "file" ? input.file.name : input.stringSample; + header = header.slice(0, 100).replace(/[\n\r\u2028\u2029]/g, ""); self.postMessage({ action: "updateTabHeader", data: { inputNum: inputNum, - input: inputData.slice(0, 100) + input: header } }); }; @@ -445,42 +426,19 @@ self.updateTabHeader = function(inputNum) { * @param {boolean} inputData.silent - If false, the manager statechange event will be fired */ self.setInput = function(inputData) { - const inputNum = inputData.inputNum; - const silent = inputData.silent; - const input = self.getInputObj(inputNum); - if (input === undefined || input === null) return; + const {inputNum, silent} = inputData; + const input = self.inputs[inputNum]; + if (!input) return; - let inputVal = input.data; - const inputObj = { - inputNum: inputNum, - input: inputVal - }; - if (typeof inputVal !== "string") { - inputObj.name = inputVal.name; - inputObj.size = inputVal.size; - inputObj.type = inputVal.type; - inputObj.progress = input.progress; - inputObj.status = input.status; - inputVal = inputVal.fileBuffer; - const fileSlice = inputVal.slice(0, 512001); - inputObj.input = fileSlice; + self.postMessage({ + action: "setInput", + data: { + inputNum: inputNum, + inputObj: input, + silent: silent + } + }); - self.postMessage({ - action: "setInput", - data: { - inputObj: inputObj, - silent: silent - } - }, [fileSlice]); - } else { - self.postMessage({ - action: "setInput", - data: { - inputObj: inputObj, - silent: silent - } - }); - } self.updateTabHeader(inputNum); }; @@ -533,8 +491,7 @@ self.updateInputStatus = function(inputNum, status) { * @param {number} inputData.progress - The load progress of the input */ self.updateInputProgress = function(inputData) { - const inputNum = inputData.inputNum; - const progress = inputData.progress; + const {inputNum, progress} = inputData; if (self.inputs[inputNum] !== undefined) { self.inputs[inputNum].progress = progress; @@ -546,54 +503,31 @@ self.updateInputProgress = function(inputData) { * * @param {object} inputData * @param {number} inputData.inputNum - The input that's having its value updated - * @param {string | ArrayBuffer} inputData.value - The new value of the input - * @param {boolean} inputData.force - If true, still updates the input value if the input type is different to the stored value + * @param {ArrayBuffer} inputData.buffer - The new value of the input as a buffer + * @param {number} [inputData.encoding] - The character encoding of the input data + * @param {string} [inputData.eolSequence] - The end of line sequence of the input data + * @param {string} [inputData.stringSample] - A sample of the value as a string (truncated to 4096 chars) */ self.updateInputValue = function(inputData) { - const inputNum = inputData.inputNum; + const inputNum = parseInt(inputData.inputNum, 10); if (inputNum < 1) return; - if (Object.prototype.hasOwnProperty.call(self.inputs[inputNum].data, "fileBuffer") && - typeof inputData.value === "string" && !inputData.force) return; - const value = inputData.value; - if (self.inputs[inputNum] !== undefined) { - if (typeof value === "string") { - self.inputs[inputNum].data = value; - } else { - self.inputs[inputNum].data.fileBuffer = value; - } - self.inputs[inputNum].status = "loaded"; - self.inputs[inputNum].progress = 100; - return; + + if (!Object.prototype.hasOwnProperty.call(self.inputs, inputNum)) + throw new Error(`No input with ID ${inputNum} exists`); + + self.inputs[inputNum].buffer = inputData.buffer; + if ("encoding" in inputData) { + self.inputs[inputNum].encoding = inputData.encoding; } - - // If we get to here, an input for inputNum could not be found, - // so create a new one. Only do this if the value is a string, as - // loadFiles will create the input object for files - if (typeof value === "string") { - self.inputs.push({ - inputNum: inputNum, - data: value, - status: "loaded", - progress: 100 - }); + if ("eolSequence" in inputData) { + self.inputs[inputNum].eolSequence = inputData.eolSequence; } -}; - -/** - * Update the stored data object for an input. - * Used if we need to change a string to an ArrayBuffer - * - * @param {object} inputData - * @param {number} inputData.inputNum - The number of the input we're updating - * @param {object} inputData.data - The new data object for the input - */ -self.updateInputObj = function(inputData) { - const inputNum = inputData.inputNum; - const data = inputData.data; - - if (self.getInputObj(inputNum) === undefined) return; - - self.inputs[inputNum].data = data; + if (!("stringSample" in inputData)) { + inputData.stringSample = Utils.arrayBufferToStr(inputData.buffer.slice(0, 4096)); + } + self.inputs[inputNum].stringSample = inputData.stringSample; + self.inputs[inputNum].status = "loaded"; + self.inputs[inputNum].progress = 100; }; /** @@ -632,8 +566,7 @@ self.loaderWorkerReady = function(workerData) { /** * Handler for messages sent by loaderWorkers. - * (Messages are sent between the inputWorker and - * loaderWorkers via the main thread) + * (Messages are sent between the inputWorker and loaderWorkers via the main thread) * * @param {object} r - The data sent by the loaderWorker * @param {number} r.inputNum - The inputNum which the message corresponds to @@ -667,7 +600,7 @@ self.handleLoaderMessage = function(r) { self.updateInputValue({ inputNum: inputNum, - value: r.fileBuffer + buffer: r.fileBuffer }); self.postMessage({ @@ -752,12 +685,12 @@ self.terminateLoaderWorker = function(id) { * @param {number} filesData.activeTab - The active tab in the UI */ self.loadFiles = function(filesData) { - const files = filesData.files; - const activeTab = filesData.activeTab; + const {files, activeTab} = filesData; let lastInputNum = -1; const inputNums = []; for (let i = 0; i < files.length; i++) { - if (i === 0 && self.getInputValue(activeTab) === "") { + // If the first input is empty, replace it rather than adding a new one + if (i === 0 && (!self.inputs[activeTab].buffer || self.inputs[activeTab].buffer.byteLength === 0)) { self.removeInput({ inputNum: activeTab, refreshTabs: false, @@ -791,14 +724,14 @@ self.loadFiles = function(filesData) { } self.getLoadProgress(); - self.setInput({inputNum: activeTab, silent: true}); + self.setInput({inputNum: lastInputNum, silent: true}); }; /** * Adds an input to the input dictionary * * @param {boolean} [changetab=false] - Whether or not to change to the new input - * @param {string} type - Either "string" or "file" + * @param {string} type - Either "userinput" or "file" * @param {Object} fileData - Contains information about the file to be added to the input (only used when type is "file") * @param {string} fileData.name - The filename of the input being added * @param {number} fileData.size - The file size (in bytes) of the input being added @@ -810,25 +743,32 @@ self.addInput = function( type, fileData = { name: "unknown", - size: "unknown", + size: 0, type: "unknown" }, inputNum = self.currentInputNum++ ) { self.numInputs++; const newInputObj = { - inputNum: inputNum + type: null, + buffer: new ArrayBuffer(), + stringSample: "", + file: null, + status: "pending", + progress: 0, + encoding: 0, + eolSequence: "\u000a" }; switch (type) { - case "string": - newInputObj.data = ""; + case "userinput": + newInputObj.type = "userinput"; newInputObj.status = "loaded"; newInputObj.progress = 100; break; case "file": - newInputObj.data = { - fileBuffer: new ArrayBuffer(), + newInputObj.type = "file"; + newInputObj.file = { name: fileData.name, size: fileData.size, type: fileData.type @@ -837,7 +777,7 @@ self.addInput = function( newInputObj.progress = 0; break; default: - log.error(`Invalid type '${type}'.`); + log.error(`Invalid input type '${type}'.`); return -1; } self.inputs[inputNum] = newInputObj; @@ -976,18 +916,18 @@ self.filterTabs = function(searchData) { self.inputs[iNum].status === "loading" && showLoading || self.inputs[iNum].status === "loaded" && showLoaded) { try { - if (typeof self.inputs[iNum].data === "string") { + if (self.inputs[iNum].type === "userinput") { if (filterType.toLowerCase() === "content" && - filterExp.test(self.inputs[iNum].data.slice(0, 4096))) { - textDisplay = self.inputs[iNum].data.slice(0, 4096); + filterExp.test(self.inputs[iNum].stringSample)) { + textDisplay = self.inputs[iNum].stringSample; addInput = true; } } else { if ((filterType.toLowerCase() === "filename" && - filterExp.test(self.inputs[iNum].data.name)) || - filterType.toLowerCase() === "content" && - filterExp.test(Utils.arrayBufferToStr(self.inputs[iNum].data.fileBuffer.slice(0, 4096)))) { - textDisplay = self.inputs[iNum].data.name; + filterExp.test(self.inputs[iNum].file.name)) || + (filterType.toLowerCase() === "content" && + filterExp.test(self.inputs[iNum].stringSample))) { + textDisplay = self.inputs[iNum].file.name; addInput = true; } } @@ -1021,61 +961,3 @@ self.filterTabs = function(searchData) { data: inputs }); }; - -/** - * Swaps the input and outputs, and sends the old input back to the main thread. - * - * @param {object} switchData - * @param {number} switchData.inputNum - The inputNum of the input to be switched to - * @param {string | ArrayBuffer} switchData.outputData - The data to switch to - */ -self.inputSwitch = function(switchData) { - const currentInput = self.getInputObj(switchData.inputNum); - const currentData = currentInput.data; - if (currentInput === undefined || currentInput === null) return; - - if (typeof switchData.outputData !== "string") { - const output = new Uint8Array(switchData.outputData), - types = detectFileType(output); - let type = "unknown", - ext = "dat"; - if (types.length) { - type = types[0].mime; - ext = types[0].extension.split(",", 1)[0]; - } - - // ArrayBuffer - self.updateInputObj({ - inputNum: switchData.inputNum, - data: { - fileBuffer: switchData.outputData, - name: `output.${ext}`, - size: switchData.outputData.byteLength.toLocaleString(), - type: type - } - }); - } else { - // String - self.updateInputValue({ - inputNum: switchData.inputNum, - value: switchData.outputData, - force: true - }); - } - - self.postMessage({ - action: "inputSwitch", - data: { - data: currentData, - inputNum: switchData.inputNum - } - }); - - self.postMessage({ - action: "fileLoaded", - data: { - inputNum: switchData.inputNum - } - }); - -}; diff --git a/src/web/workers/LoaderWorker.js b/src/web/workers/LoaderWorker.js index 4c38998e..ef6280f0 100755 --- a/src/web/workers/LoaderWorker.js +++ b/src/web/workers/LoaderWorker.js @@ -6,32 +6,36 @@ * @license Apache-2.0 */ +import loglevelMessagePrefix from "loglevel-message-prefix"; + +loglevelMessagePrefix(log, { + prefixes: [], + staticPrefixes: ["LoaderWorker"] +}); + self.id = null; -self.handleMessage = function(e) { - const r = e.data; - log.debug(`LoaderWorker receiving command '${r.action}'`); - - switch (r.action) { - case "loadInput": - self.loadFile(r.data.file, r.data.inputNum); - break; - } -}; - - /** * Respond to message from parent thread. */ self.addEventListener("message", function(e) { + // Handle message const r = e.data; - if (Object.prototype.hasOwnProperty.call(r, "file") && Object.prototype.hasOwnProperty.call(r, "inputNum")) { - self.loadFile(r.file, r.inputNum); - } else if (Object.prototype.hasOwnProperty.call(r, "file")) { - self.loadFile(r.file, ""); - } else if (Object.prototype.hasOwnProperty.call(r, "id")) { - self.id = r.id; + log.debug(`Receiving command '${r.action}'`); + + switch (r.action) { + case "setID": + self.id = r.data.id; + break; + case "loadFile": + self.loadFile(r.data.file, r.data?.inputNum ?? ""); + break; + case "setLogLevel": + log.setLevel(r.data, false); + break; + default: + log.error(`Unknown action '${r.action}'.`); } }); diff --git a/src/web/workers/ZipWorker.mjs b/src/web/workers/ZipWorker.mjs index 85a8cb4c..f81e2b2c 100644 --- a/src/web/workers/ZipWorker.mjs +++ b/src/web/workers/ZipWorker.mjs @@ -10,6 +10,12 @@ import zip from "zlibjs/bin/zip.min.js"; import Utils from "../../core/Utils.mjs"; import Dish from "../../core/Dish.mjs"; import {detectFileType} from "../../core/lib/FileType.mjs"; +import loglevelMessagePrefix from "loglevel-message-prefix"; + +loglevelMessagePrefix(log, { + prefixes: [], + staticPrefixes: ["ZipWorker"], +}); const Zlib = zip.Zlib; @@ -17,17 +23,20 @@ const Zlib = zip.Zlib; * Respond to message from parent thread. */ self.addEventListener("message", function(e) { + // Handle message from the main thread const r = e.data; - if (!("outputs" in r)) { - log.error("No files were passed to the ZipWorker."); - return; - } - if (!("filename" in r)) { - log.error("No filename was passed to the ZipWorker"); - return; - } + log.debug(`Receiving command '${r.action}'`); - self.zipFiles(r.outputs, r.filename, r.fileExtension); + switch (r.action) { + case "zipFiles": + self.zipFiles(r.data.outputs, r.data.filename, r.data.fileExtension); + break; + case "setLogLevel": + log.setLevel(r.data, false); + break; + default: + log.error(`Unknown action: '${r.action}'`); + } }); self.setOption = function(...args) {}; diff --git a/tests/browser/nightwatch.js b/tests/browser/00_nightwatch.js similarity index 87% rename from tests/browser/nightwatch.js rename to tests/browser/00_nightwatch.js index 41aff9b2..e64b476b 100644 --- a/tests/browser/nightwatch.js +++ b/tests/browser/00_nightwatch.js @@ -6,6 +6,8 @@ * @license Apache-2.0 */ +const utils = require("./browserUtils.js"); + module.exports = { before: browser => { browser @@ -82,7 +84,7 @@ module.exports = { // Enter input browser .useCss() - .setValue("#input-text", "Don't Panic.") + .sendKeys("#input-text .cm-content", "Don't Panic.") .pause(1000) .click("#bake"); @@ -90,7 +92,7 @@ module.exports = { browser .useCss() .waitForElementNotVisible("#stale-indicator", 1000) - .expect.element("#output-text").to.have.property("value").that.equals("44 6f 6e 27 74 20 50 61 6e 69 63 2e"); + .expect.element("#output-text .cm-content").text.that.equals("44 6f 6e 27 74 20 50 61 6e 69 63 2e"); // Clear recipe browser @@ -192,6 +194,9 @@ module.exports = { // Open category browser + .useCss() + .waitForElementNotVisible("#snackbar-container", 10000) + .useXpath() .click(otherCat) .expect.element(genUUID).to.be.visible; @@ -206,7 +211,7 @@ module.exports = { .useCss() .waitForElementVisible(".operation .op-title", 1000) .waitForElementNotVisible("#stale-indicator", 1000) - .expect.element("#output-text").to.have.property("value").which.matches(/[\da-f-]{36}/); + .expect.element("#output-text .cm-content").text.which.matches(/[\da-f-]{36}/); browser.click("#clr-recipe"); }, @@ -221,6 +226,25 @@ module.exports = { .waitForElementVisible("//ul[@id='search-results']//b[text()='MD5']", 1000); }, + "Alert bar": browser => { + // Bake nothing to create an empty output which can be copied + utils.clear(browser); + utils.bake(browser); + + // Alert bar shows and contains correct content + browser + .waitForElementNotVisible("#snackbar-container") + .click("#copy-output") + .waitForElementVisible("#snackbar-container .snackbar-content") + .expect.element("#snackbar-container .snackbar-content").text.to.equal("Copied raw output successfully."); + + // Alert bar disappears after the correct amount of time + // Should disappear after 2000ms + browser + .waitForElementNotPresent("#snackbar-container .snackbar-content", 2500) + .waitForElementNotVisible("#snackbar-container"); + }, + after: browser => { browser.end(); } diff --git a/tests/browser/01_io.js b/tests/browser/01_io.js new file mode 100644 index 00000000..cbfec083 --- /dev/null +++ b/tests/browser/01_io.js @@ -0,0 +1,753 @@ +/** + * Tests for input and output of various types to ensure the editors work as expected + * and retain data integrity, especially when it comes to special characters. + * + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2023 + * @license Apache-2.0 + */ + +// import { +// clear, +// utils.setInput, +// bake, +// setChrEnc, +// setEOLSeq, +// copy, +// paste, +// loadRecipe, +// expectOutput, +// uploadFile, +// uploadFolder +// } from "./browserUtils.js"; + +const utils = require("./browserUtils.js"); + +const SPECIAL_CHARS = [ + "\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009\u000a\u000b\u000c\u000d\u000e\u000f", + "\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f", + "\u007f", + "\u0080\u0081\u0082\u0083\u0084\u0085\u0086\u0087\u0088\u0089\u008a\u008b\u008c\u008d\u008e\u008f", + "\u0090\u0091\u0092\u0093\u0094\u0095\u0096\u0097\u0098\u0099\u009a\u009b\u009c\u009d\u009e\u009f", + "\u00ad\u061c\u200b\u200e\u200f\u2028\u2029\u202d\u202e\u2066\u2067\u2069\ufeff\ufff9\ufffa\ufffb\ufffc" +].join(""); + +const ALL_BYTES = [ + "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", + "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", + "\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f", + "\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f", + "\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f", + "\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f", + "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f", + "\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f", + "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f", + "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f", + "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf", + "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf", + "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf", + "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf", + "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef", + "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff", +].join(""); + +const PUA_CHARS = "\ue000\ue001\uf8fe\uf8ff"; + +const MULTI_LINE_STRING =`"You know," said Arthur, "it's at times like this, when I'm trapped in a Vogon airlock with a man from Betelgeuse, and about to die of asphyxiation in deep space that I really wish I'd listened to what my mother told me when I was young." +"Why, what did she tell you?" +"I don't know, I didn't listen."`; + +const SELECTABLE_STRING = `ONE +two +ONE +three +ONE +four +ONE`; + +// Descriptions for named control characters +const CONTROL_CHAR_NAMES = { + 0: "null", + 7: "bell", + 8: "backspace", + 10: "line feed", + 11: "vertical tab", + 13: "carriage return", + 27: "escape", + 8203: "zero width space", + 8204: "zero width non-joiner", + 8205: "zero width joiner", + 8206: "left-to-right mark", + 8207: "right-to-left mark", + 8232: "line separator", + 8237: "left-to-right override", + 8238: "right-to-left override", + 8294: "left-to-right isolate", + 8295: "right-to-left isolate", + 8297: "pop directional isolate", + 8233: "paragraph separator", + 65279: "zero width no-break space", + 65532: "object replacement" +}; + +module.exports = { + before: browser => { + browser + .resizeWindow(1280, 800) + .url(browser.launchUrl) + .useCss() + .waitForElementNotPresent("#preloader", 10000) + .click("#auto-bake-label"); + }, + + "CodeMirror has loaded correctly": browser => { + /* Editor has initialised */ + browser + .useCss() + // Input + .waitForElementVisible("#input-text") + .waitForElementVisible("#input-text .cm-editor") + .waitForElementVisible("#input-text .cm-editor .cm-scroller") + .waitForElementVisible("#input-text .cm-editor .cm-scroller .cm-content") + .waitForElementVisible("#input-text .cm-editor .cm-scroller .cm-content .cm-line") + // Output + .waitForElementVisible("#output-text") + .waitForElementVisible("#output-text .cm-editor") + .waitForElementVisible("#output-text .cm-editor .cm-scroller") + .waitForElementVisible("#output-text .cm-editor .cm-scroller .cm-content") + .waitForElementVisible("#output-text .cm-editor .cm-scroller .cm-content .cm-line"); + + /* Status bar is showing and has correct values */ + browser // Input + .waitForElementVisible("#input-text .cm-status-bar") + .waitForElementVisible("#input-text .cm-status-bar .stats-length-value") + .expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("0"); + browser.waitForElementVisible("#input-text .cm-status-bar .stats-lines-value") + .expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + browser.waitForElementVisible("#input-text .cm-status-bar .chr-enc-value") + .expect.element("#input-text .cm-status-bar .chr-enc-value").text.to.equal("Raw Bytes"); + browser.waitForElementVisible("#input-text .cm-status-bar .eol-value") + .expect.element("#input-text .cm-status-bar .eol-value").text.to.equal("LF"); + + browser // Output + .waitForElementVisible("#output-text .cm-status-bar") + .waitForElementVisible("#output-text .cm-status-bar .stats-length-value") + .expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("0"); + browser.waitForElementVisible("#output-text .cm-status-bar .stats-lines-value") + .expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + browser.waitForElementVisible("#output-text .cm-status-bar .baking-time-info") + .expect.element("#output-text .cm-status-bar .baking-time-info").text.to.contain("ms"); + browser.waitForElementVisible("#output-text .cm-status-bar .chr-enc-value") + .expect.element("#output-text .cm-status-bar .chr-enc-value").text.to.equal("Raw Bytes"); + browser.waitForElementVisible("#output-text .cm-status-bar .eol-value") + .expect.element("#output-text .cm-status-bar .eol-value").text.to.equal("LF"); + }, + + "Adding content": browser => { + /* Status bar updates correctly */ + utils.setInput(browser, MULTI_LINE_STRING); + + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("3"); + browser.expect.element("#input-text .cm-status-bar .chr-enc-value").text.to.equal("Raw Bytes"); + browser.expect.element("#input-text .cm-status-bar .eol-value").text.to.equal("LF"); + + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("0"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + browser.expect.element("#output-text .cm-status-bar .baking-time-info").text.to.contain("ms"); + browser.expect.element("#output-text .cm-status-bar .chr-enc-value").text.to.equal("Raw Bytes"); + browser.expect.element("#output-text .cm-status-bar .eol-value").text.to.equal("LF"); + + /* Output updates correctly */ + utils.bake(browser); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("3"); + browser.expect.element("#output-text .cm-status-bar .baking-time-info").text.to.contain("ms"); + browser.expect.element("#output-text .cm-status-bar .chr-enc-value").text.to.equal("Raw Bytes"); + browser.expect.element("#output-text .cm-status-bar .eol-value").text.to.equal("LF"); + }, + + "Autobaking the latest input": browser => { + // Use the sleep recipe to simulate a long running task + utils.loadRecipe(browser, "Sleep", "input", [2000]); + + browser.waitForElementVisible("#stale-indicator"); + + // Enable previously disabled autobake + browser.expect.element("#auto-bake").to.not.be.selected; + browser.click("#auto-bake-label"); + browser.expect.element("#auto-bake").to.be.selected.before(1000); + + // Add content to the input + browser.pause(100); + browser.sendKeys("#input-text .cm-content", "1"); + browser.waitForElementVisible("#output-loader"); + browser.pause(500); + + // Make another change while the previous input is being baked + browser + .sendKeys("#input-text .cm-content", "2") + .waitForElementNotVisible("#stale-indicator") + .waitForElementNotVisible("#output-loader"); + + // Ensure we got the latest input baked + utils.expectOutput(browser, "input12"); + + // Turn autobake off again + browser.click("#auto-bake-label"); + browser.expect.element("#auto-bake").to.not.be.selected.before(1000); + }, + + "Special content": browser => { + /* Special characters are rendered correctly */ + utils.setInput(browser, SPECIAL_CHARS, false); + + // First line + for (let i = 0x0; i <= 0x8; i++) { + browser.expect.element(`#input-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(${i+1})`) + .to.have.property("title").equals(`Control character ${CONTROL_CHAR_NAMES[i] || "0x" + i.toString(16)}`); + browser.expect.element(`#input-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(${i+1})`) + .text.to.equal(String.fromCharCode(0x2400 + i)); + } + + // Tab \u0009 + browser.expect.element(`#input-text .cm-line:nth-of-type(1)`).to.have.property("textContent").match(/\u0009$/); + + // Line feed \u000a + browser.expect.element(`#input-text .cm-line:nth-of-type(1)`).to.have.property("textContent").match(/^.{10}$/); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + // Second line + for (let i = 0x0b; i < SPECIAL_CHARS.length; i++) { + const index = SPECIAL_CHARS.charCodeAt(i); + const name = CONTROL_CHAR_NAMES[index] || "0x" + index.toString(16); + const value = index >= 32 ? "\u2022" : String.fromCharCode(0x2400 + index); + + browser.expect.element(`#input-text .cm-line:nth-of-type(2) .cm-specialChar:nth-of-type(${i-10})`) + .to.have.property("title").equals(`Control character ${name}`); + browser.expect.element(`#input-text .cm-line:nth-of-type(2) .cm-specialChar:nth-of-type(${i-10})`) + .text.to.equal(value); + } + + /* Output renders correctly */ + utils.setChrEnc(browser, "output", "UTF-8"); + utils.bake(browser); + + // First line + for (let i = 0x0; i <= 0x8; i++) { + browser.expect.element(`#output-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(${i+1})`) + .to.have.property("title").equals(`Control character ${CONTROL_CHAR_NAMES[i] || "0x" + i.toString(16)}`); + browser.expect.element(`#output-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(${i+1})`) + .text.to.equal(String.fromCharCode(0x2400 + i)); + } + + // Tab \u0009 + browser.expect.element(`#output-text .cm-line:nth-of-type(1)`).to.have.property("textContent").match(/\u0009$/); + + // Line feed \u000a + browser.expect.element(`#output-text .cm-line:nth-of-type(1)`).to.have.property("textContent").match(/^.{10}$/); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + // Second line + for (let i = 0x0b; i < SPECIAL_CHARS.length; i++) { + const index = SPECIAL_CHARS.charCodeAt(i); + const name = CONTROL_CHAR_NAMES[index] || "0x" + index.toString(16); + const value = index >= 32 ? "\u2022" : String.fromCharCode(0x2400 + index); + + browser.expect.element(`#output-text .cm-content .cm-line:nth-of-type(2) .cm-specialChar:nth-of-type(${i-10})`) + .to.have.property("title").equals(`Control character ${name}`); + browser.expect.element(`#output-text .cm-content .cm-line:nth-of-type(2) .cm-specialChar:nth-of-type(${i-10})`) + .text.to.equal(value); + } + + /* Bytes are rendered correctly */ + utils.setInput(browser, ALL_BYTES, false); + // Expect length to be 255, since one character is creating a newline + browser.expect.element(`#input-text .cm-content`).to.have.property("textContent").match(/^.{255}$/); + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("256"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + + /* PUA \ue000-\uf8ff */ + utils.setInput(browser, PUA_CHARS, false); + utils.setChrEnc(browser, "output", "UTF-8"); + utils.bake(browser); + + // Confirm input and output as expected + /* In order to render whitespace characters as control character pictures in the output, even + when they are the designated line separator, CyberChef sometimes chooses to represent them + internally using the Unicode Private Use Area (https://en.wikipedia.org/wiki/Private_Use_Areas). + See `Utils.escapeWhitespace()` for an example of this. + Therefore, PUA characters should be rendered normally in the Input but as control character + pictures in the output. + */ + browser.expect.element(`#input-text .cm-content`).to.have.property("textContent").match(/^\ue000\ue001\uf8fe\uf8ff$/); + browser.expect.element(`#output-text .cm-content`).to.have.property("textContent").match(/^\u2400\u2401\u3cfe\u3cff$/); + + /* Can be copied */ + utils.setInput(browser, SPECIAL_CHARS, false); + utils.setChrEnc(browser, "output", "UTF-8"); + utils.bake(browser); + + // Manual copy + browser + .doubleClick("#output-text .cm-content .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(1)") + .waitForElementVisible("#output-text .cm-selectionBackground"); + utils.copy(browser); + utils.paste(browser, "#search"); // Paste into search box as this won't mess with the values + + // Ensure that the values are as expected + browser.expect.element("#search").to.have.value.that.equals("\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008"); + browser.clearValue("#search"); + + // Raw copy + browser + .click("#copy-output") + .pause(100); + utils.paste(browser, "#search"); // Paste into search box as this won't mess with the values + + // Ensure that the values are as expected + browser.expect.element("#search").to.have.value.that.matches(/^\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009/); + browser.clearValue("#search"); + }, + + "HTML output": browser => { + /* Displays correctly */ + utils.loadRecipe(browser, "Entropy", ALL_BYTES); + utils.bake(browser); + + browser + .waitForElementVisible("#output-html") + .waitForElementVisible("#output-html #chart-area"); + + /* Status bar widgets are disabled */ + browser.expect.element("#output-text .cm-status-bar .disabled .stats-length-value").to.be.visible; + browser.expect.element("#output-text .cm-status-bar .disabled .stats-lines-value").to.be.visible; + browser.expect.element("#output-text .cm-status-bar .disabled .chr-enc-value").to.be.visible; + browser.expect.element("#output-text .cm-status-bar .disabled .eol-value").to.be.visible; + + /* Displays special chars correctly */ + utils.loadRecipe(browser, "To Table", ",\u0000\u0001\u0002\u0003\u0004", [",", "\\r\\n", false, "HTML"]); + utils.bake(browser); + + for (let i = 0x0; i <= 0x4; i++) { + browser.expect.element(`#output-html .cm-specialChar:nth-of-type(${i+1})`) + .to.have.property("title").equals(`Control character ${CONTROL_CHAR_NAMES[i] || "0x" + i.toString(16)}`); + browser.expect.element(`#output-html .cm-specialChar:nth-of-type(${i+1})`) + .text.to.equal(String.fromCharCode(0x2400 + i)); + } + + /* Can be copied */ + // Raw copy + browser + .click("#copy-output") + .pause(100); + utils.paste(browser, "#search"); // Paste into search box as this won't mess with the values + + // Ensure that the values are as expected + browser.expect.element("#search").to.have.value.that.matches(/\u0000\u0001\u0002\u0003\u0004/); + browser.clearValue("#search"); + }, + + "Highlighting": browser => { + utils.setInput(browser, SELECTABLE_STRING); + utils.bake(browser); + + /* Selecting input text also selects other instances in input and output */ + browser // Input + .click("#auto-bake-label") + .doubleClick("#input-text .cm-content .cm-line:nth-of-type(1)") + .waitForElementVisible("#input-text .cm-selectionLayer .cm-selectionBackground") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(1) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(2) .cm-selectionMatch") + .waitForElementVisible("#input-text .cm-content .cm-line:nth-of-type(3) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(4) .cm-selectionMatch") + .waitForElementVisible("#input-text .cm-content .cm-line:nth-of-type(5) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(6) .cm-selectionMatch") + .waitForElementVisible("#input-text .cm-content .cm-line:nth-of-type(7) .cm-selectionMatch"); + + browser // Output + .waitForElementVisible("#output-text .cm-selectionLayer .cm-selectionBackground") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(1) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(2) .cm-selectionMatch") + .waitForElementVisible("#output-text .cm-content .cm-line:nth-of-type(3) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(4) .cm-selectionMatch") + .waitForElementVisible("#output-text .cm-content .cm-line:nth-of-type(5) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(6) .cm-selectionMatch") + .waitForElementVisible("#output-text .cm-content .cm-line:nth-of-type(7) .cm-selectionMatch"); + + /* Selecting output text highlights in input */ + browser // Output + .click("#output-text") + .waitForElementNotPresent("#input-text .cm-selectionLayer .cm-selectionBackground") + .waitForElementNotPresent("#output-text .cm-selectionLayer .cm-selectionBackground") + .waitForElementNotPresent("#input-text .cm-content .cm-line .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line .cm-selectionMatch") + .doubleClick("#output-text .cm-content .cm-line:nth-of-type(7)") + .waitForElementVisible("#output-text .cm-selectionLayer .cm-selectionBackground") + .waitForElementVisible("#output-text .cm-content .cm-line:nth-of-type(1) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(2) .cm-selectionMatch") + .waitForElementVisible("#output-text .cm-content .cm-line:nth-of-type(3) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(4) .cm-selectionMatch") + .waitForElementVisible("#output-text .cm-content .cm-line:nth-of-type(5) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(6) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(7) .cm-selectionMatch"); + + browser // Input + .waitForElementVisible("#input-text .cm-selectionLayer .cm-selectionBackground") + .waitForElementVisible("#input-text .cm-content .cm-line:nth-of-type(1) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(2) .cm-selectionMatch") + .waitForElementVisible("#input-text .cm-content .cm-line:nth-of-type(3) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(4) .cm-selectionMatch") + .waitForElementVisible("#input-text .cm-content .cm-line:nth-of-type(5) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(6) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(7) .cm-selectionMatch"); + + // Turn autobake off again + browser.click("#auto-bake-label"); + }, + + "Character encoding": browser => { + const CHINESE_CHARS = "不要恐慌。"; + /* Dropup works */ + /* Selecting changes output correctly */ + utils.setInput(browser, CHINESE_CHARS, false); + utils.setChrEnc(browser, "input", "UTF-8"); + utils.bake(browser); + + /* Output encoding should be autodetected */ + browser + .waitForElementVisible("#snackbar-container .snackbar-content", 5000) + .expect.element("#snackbar-container .snackbar-content").text.to.equal("Output character encoding has been detected and changed to UTF-8"); + + utils.expectOutput(browser, CHINESE_CHARS); + + /* Change the output encoding manually to test for URL presence */ + utils.setChrEnc(browser, "output", "UTF-8"); + + /* Encodings appear in the URL */ + browser.assert.urlContains("ienc=65001"); + browser.assert.urlContains("oenc=65001"); + + /* Preserved when changing tabs */ + browser + .click("#btn-new-tab") + .waitForElementVisible("#input-tabs li:nth-of-type(2).active-input-tab"); + browser.expect.element("#input-text .chr-enc-value").text.that.equals("Raw Bytes"); + browser.expect.element("#output-text .chr-enc-value").text.that.equals("Raw Bytes"); + + utils.setChrEnc(browser, "input", "UTF-7"); + utils.setChrEnc(browser, "output", "UTF-7"); + + browser + .click("#input-tabs li:nth-of-type(1)") + .waitForElementVisible("#input-tabs li:nth-of-type(1).active-input-tab"); + browser.expect.element("#input-text .chr-enc-value").text.that.equals("UTF-8"); + browser.expect.element("#output-text .chr-enc-value").text.that.equals("UTF-8"); + + /* Try various encodings */ + // These are not meant to be realistic encodings for this data + utils.setInput(browser, CHINESE_CHARS, false); + utils.setChrEnc(browser, "input", "UTF-8"); + utils.setChrEnc(browser, "output", "UTF-16LE"); + utils.bake(browser); + utils.expectOutput(browser, "\uB8E4\uE88D\u81A6\u81E6\uE690\u8C85\u80E3"); + + utils.setChrEnc(browser, "output", "Simplified Chinese GBK"); + utils.bake(browser); + utils.expectOutput(browser, "\u6D93\u5D88\uFDFF\u93AD\u612D\u53A1\u9286\u0000"); + + utils.setChrEnc(browser, "input", "UTF-7"); + utils.bake(browser); + utils.expectOutput(browser, "+Tg0-+iYE-+YFA-+YUw-"); + + utils.setChrEnc(browser, "input", "Traditional Chinese Big5"); + utils.bake(browser); + utils.expectOutput(browser, "\u3043\u74B6\uFDFF\u7A3A\uFDFF"); + + utils.setChrEnc(browser, "output", "Windows-1251 Cyrillic"); + utils.bake(browser); + utils.expectOutput(browser, "\u00A4\u0408\u00ADn\u00AE\u0408\u00B7W\u040EC"); + }, + + "Line endings": browser => { + /* Dropup works */ + /* Selecting changes view in input */ + utils.setInput(browser, MULTI_LINE_STRING); + + // Line endings: LF + + // Input + browser + .waitForElementPresent("#input-text .cm-content .cm-line:nth-of-type(3)") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(4)") + .waitForElementNotPresent("#input-text .cm-content .cm-specialChar"); + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("3"); + + // Output + utils.bake(browser); + browser + .waitForElementPresent("#output-text .cm-content .cm-line:nth-of-type(3)") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(4)") + .waitForElementNotPresent("#output-text .cm-content .cm-specialChar"); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("3"); + + // Input EOL: VT + utils.setEOLSeq(browser, "input", "VT"); + + // Input + browser + .waitForElementPresent("#input-text .cm-content .cm-line:nth-of-type(1)") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementPresent("#input-text .cm-content .cm-specialChar"); + browser.expect.element("#input-text .cm-content .cm-specialChar").text.to.equal("␊"); + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + + // Output + utils.bake(browser); + browser + .waitForElementPresent("#output-text .cm-content .cm-line:nth-of-type(3)") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(4)") + .waitForElementNotPresent("#output-text .cm-content .cm-specialChar"); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("3"); + + // Output EOL: VT + utils.setEOLSeq(browser, "output", "VT"); + + // Input + browser + .waitForElementPresent("#input-text .cm-content .cm-line:nth-of-type(1)") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementPresent("#input-text .cm-content .cm-specialChar"); + browser.expect.element("#input-text .cm-content .cm-specialChar").text.to.equal("␊"); + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + + // Output + browser + .waitForElementPresent("#output-text .cm-content .cm-line:nth-of-type(1)") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementPresent("#output-text .cm-content .cm-specialChar"); + browser.expect.element("#output-text .cm-content .cm-specialChar").text.to.equal("␊"); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + + /* Adding new line ending changes output correctly */ + browser.sendKeys("#input-text .cm-content", browser.Keys.RETURN); + + // Input + browser + .waitForElementPresent("#input-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(3)"); + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("302"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + // Output + utils.bake(browser); + browser + .waitForElementPresent("#output-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(3)"); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("302"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + // Input EOL: CRLF + utils.setEOLSeq(browser, "input", "CRLF"); + // Output EOL: CR + utils.setEOLSeq(browser, "output", "CR"); + browser.sendKeys("#input-text .cm-content", browser.Keys.RETURN); + + // Input + browser + .waitForElementPresent("#input-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(3)") + .waitForElementPresent("#input-text .cm-content .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(3)"); + browser.expect.element("#input-text .cm-content .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(3)").text.to.equal("␋"); + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("304"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + // Output + utils.bake(browser); + browser + .waitForElementPresent("#output-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(3)") + .waitForElementPresent("#output-text .cm-content .cm-line:nth-of-type(2) .cm-specialChar"); + browser.expect.element("#output-text .cm-content .cm-line:nth-of-type(2) .cm-specialChar").text.to.equal("␊"); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("304"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + /* Line endings appear in the URL */ + browser.assert.urlContains("ieol=CRLF"); + browser.assert.urlContains("oeol=CR"); + + /* Preserved when changing tabs */ + browser + .click("#btn-new-tab") + .waitForElementVisible("#input-tabs li:nth-of-type(2).active-input-tab"); + browser.expect.element("#input-text .eol-value").text.that.equals("LF"); + browser.expect.element("#output-text .eol-value").text.that.equals("LF"); + + utils.setEOLSeq(browser, "input", "FF"); + utils.setEOLSeq(browser, "output", "LS"); + + browser + .click("#input-tabs li:nth-of-type(1)") + .waitForElementVisible("#input-tabs li:nth-of-type(1).active-input-tab"); + browser.expect.element("#input-text .eol-value").text.that.equals("CRLF"); + browser.expect.element("#output-text .eol-value").text.that.equals("CR"); + }, + + "File inputs": browser => { + utils.clear(browser); + + /* Side panel displays correct info */ + utils.uploadFile(browser, "files/TowelDay.jpeg"); + + browser + .waitForElementVisible("#input-text .cm-file-details") + .waitForElementVisible("#input-text .cm-file-details .file-details-toggle-shown") + .waitForElementVisible("#input-text .cm-file-details .file-details-thumbnail") + .waitForElementVisible("#input-text .cm-file-details .file-details-name") + .waitForElementVisible("#input-text .cm-file-details .file-details-size") + .waitForElementVisible("#input-text .cm-file-details .file-details-type") + .waitForElementVisible("#input-text .cm-file-details .file-details-loaded"); + browser.expect.element("#input-text .cm-file-details .file-details-name").text.that.equals("TowelDay.jpeg"); + browser.expect.element("#input-text .cm-file-details .file-details-size").text.that.equals("61,379 bytes"); + browser.expect.element("#input-text .cm-file-details .file-details-type").text.that.equals("image/jpeg"); + browser.expect.element("#input-text .cm-file-details .file-details-loaded").text.that.equals("100%"); + + /* Side panel can be hidden */ + browser + .click("#input-text .cm-file-details .file-details-toggle-shown") + .waitForElementNotPresent("#input-text .cm-file-details .file-details-toggle-shown") + .waitForElementVisible("#input-text .cm-file-details .file-details-toggle-hidden") + .expect.element("#input-text .cm-file-details").to.have.css("width").which.equals("1px"); + + browser + .click("#input-text .cm-file-details .file-details-toggle-hidden") + .waitForElementNotPresent("#input-text .cm-file-details .file-details-toggle-hidden") + .waitForElementVisible("#input-text .cm-file-details .file-details-toggle-shown") + .expect.element("#input-text .cm-file-details").to.have.css("width").which.equals("200px"); + }, + + "Folder inputs": browser => { + utils.clear(browser); + + /* Side panel displays correct info */ + utils.uploadFolder(browser, "files"); + + // Loop through tabs + for (let i = 1; i < 3; i++) { + browser + .click(`#input-tabs li:nth-of-type(${i})`) + .waitForElementVisible(`#input-tabs li:nth-of-type(${i}).active-input-tab`); + + browser + .waitForElementVisible("#input-text .cm-file-details") + .waitForElementVisible("#input-text .cm-file-details .file-details-toggle-shown") + .waitForElementVisible("#input-text .cm-file-details .file-details-thumbnail") + .waitForElementVisible("#input-text .cm-file-details .file-details-name") + .waitForElementVisible("#input-text .cm-file-details .file-details-size") + .waitForElementVisible("#input-text .cm-file-details .file-details-type") + .waitForElementVisible("#input-text .cm-file-details .file-details-loaded"); + + browser.getText("#input-text .cm-file-details .file-details-name", function(result) { + switch (result.value) { + case "TowelDay.jpeg": + browser.expect.element("#input-text .cm-file-details .file-details-name").text.that.equals("TowelDay.jpeg"); + browser.expect.element("#input-text .cm-file-details .file-details-size").text.that.equals("61,379 bytes"); + browser.expect.element("#input-text .cm-file-details .file-details-type").text.that.equals("image/jpeg"); + browser.expect.element("#input-text .cm-file-details .file-details-loaded").text.that.equals("100%"); + break; + case "Hitchhikers_Guide.jpeg": + browser.expect.element("#input-text .cm-file-details .file-details-name").text.that.equals("Hitchhikers_Guide.jpeg"); + browser.expect.element("#input-text .cm-file-details .file-details-size").text.that.equals("36,595 bytes"); + browser.expect.element("#input-text .cm-file-details .file-details-type").text.that.equals("image/jpeg"); + browser.expect.element("#input-text .cm-file-details .file-details-loaded").text.that.equals("100%"); + break; + default: + break; + } + }); + } + }, + + // "Loading from URL": browser => { + // utils.clear(browser); + + // /* Side panel displays correct info */ + // utils.uploadFile(browser, "files/TowelDay.jpeg"); + + // browser + // .waitForElementVisible("#input-text .cm-file-details") + // .waitForElementVisible("#input-text .cm-file-details .file-details-toggle-shown") + // .waitForElementVisible("#input-text .cm-file-details .file-details-thumbnail") + // .waitForElementVisible("#input-text .cm-file-details .file-details-name") + // .waitForElementVisible("#input-text .cm-file-details .file-details-size") + // .waitForElementVisible("#input-text .cm-file-details .file-details-type") + // .waitForElementVisible("#input-text .cm-file-details .file-details-loaded"); + + // /* Complex deep link populates the input correctly (encoding, eol, input) */ + // browser + // .urlHash("recipe=To_Base64('A-Za-z0-9%2B/%3D')&input=VGhlIHNoaXBzIGh1bmcgaW4gdGhlIHNreSBpbiBtdWNoIHRoZSBzYW1lIHdheSB0aGF0IGJyaWNrcyBkb24ndC4M&ienc=21866&oenc=1201&ieol=FF&oeol=PS") + // .waitForElementVisible("#rec-list li.operation"); + + // browser.expect.element(`#input-text .cm-content`).to.have.property("textContent").match(/^.{65}$/); + // browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("66"); + // browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + // browser.expect.element("#input-text .chr-enc-value").text.that.equals("KOI8-U Ukrainian Cyrillic"); + // browser.expect.element("#output-text .chr-enc-value").text.that.equals("UTF-16BE"); + + // browser.expect.element("#input-text .eol-value").text.that.equals("FF"); + // browser.expect.element("#output-text .eol-value").text.that.equals("PS"); + + // utils.bake(browser); + + // browser.expect.element(`#output-text .cm-content`).to.have.property("textContent").match(/^.{44}$/); + // browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("44"); + // browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + // }, + + "Replace input with output": browser => { + /* Input is correctly populated */ + utils.loadRecipe(browser, "XOR", "The ships hung in the sky in much the same way that bricks don't.", [{ "option": "Hex", "string": "65" }, "Standard", false]); + utils.setChrEnc(browser, "input", "UTF-32LE"); + utils.setChrEnc(browser, "output", "UTF-7"); + utils.setEOLSeq(browser, "input", "CRLF"); + utils.setEOLSeq(browser, "output", "LS"); + + browser + .sendKeys("#input-text .cm-content", browser.Keys.RETURN) + .expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + utils.bake(browser); + + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("67"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + browser.expect.element("#input-text .chr-enc-value").text.that.equals("UTF-32LE"); + browser.expect.element("#input-text .eol-value").text.that.equals("CRLF"); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("268"); + + browser + .click("#switch") + .waitForElementVisible("#stale-indicator"); + + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("268"); + + /* Special characters, encodings and line endings all as expected */ + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + browser.expect.element("#input-text .chr-enc-value").text.that.equals("UTF-7"); + browser.expect.element("#input-text .eol-value").text.that.equals("LS"); + browser.expect.element("#input-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(1)").text.to.equal("␍"); + browser.expect.element("#input-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(49)").text.to.equal("␑"); + browser.waitForElementNotPresent("#input-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(50)"); + }, + + + after: browser => { + browser.end(); + } +}; diff --git a/tests/browser/ops.js b/tests/browser/02_ops.js similarity index 50% rename from tests/browser/ops.js rename to tests/browser/02_ops.js index 73777c0b..896de7b0 100644 --- a/tests/browser/ops.js +++ b/tests/browser/02_ops.js @@ -1,11 +1,20 @@ /** - * Tests for operations to ensure they output something sensible where expected + * Tests for operations. + * The primary purpose for these test is to ensure that the operations + * output something vaguely expected (i.e. they aren't completely broken + * after a dependency update or changes to the UI), rather than to confirm + * that this output is actually accurate. Accuracy of output and testing + * of edge cases should be carried out in the operations test suite found + * in /tests/operations as this is much faster and easier to configure + * than the UI tests found here. * * @author n1474335 [n1474335@gmail.com] * @copyright Crown Copyright 2021 * @license Apache-2.0 */ +const utils = require("./browserUtils.js"); + module.exports = { before: browser => { browser @@ -25,40 +34,62 @@ module.exports = { testOp(browser, "AES Encrypt", "test input", "e42eb8fbfb7a98fff061cd2c1a794d92", [{"option": "Hex", "string": "00112233445566778899aabbccddeeff"}, {"option": "Hex", "string": "00000000000000000000000000000000"}, "CBC", "Raw", "Hex"]); testOp(browser, "AND", "test input", "4$04 $044", [{ "option": "Hex", "string": "34" }]); testOp(browser, "Add line numbers", "test input", "1 test input"); - testOp(browser, ["From Hex", "Add Text To Image", "To Base64"], Images.PNG_HEX, Images.PNG_CHEF_B64, [[], ["Chef", "Center", "Middle", 0, 0, 16], []]); + testOp(browser, ["From Hex", "Add Text To Image", "SHA2"], Images.PNG_HEX, "50cdf8ea483c55564a091650c2bccb4586f919b721e5fe9d6a61660505b4346d6ebdb2ef0cf075a7728cd84cb26ea3e477b5bd86a94a49a27d79423994afb60a", [[], ["Chef", "Center", "Middle", 0, 0, 16, "Roboto"], []]); + testOp(browser, ["From Hex", "Add Text To Image", "SHA2"], Images.PNG_HEX, "78b3055463d9167dd039e47f451acaf06c593d209f8e405b4e18011cdcf190dc0af5952be887d93c0ebd38738e978120c1294c71104e6b00d3f9de8d6320ec1c", [[], ["Chef", "Center", "Middle", 0, 0, 16, "Roboto Black"], []]); + testOp(browser, ["From Hex", "Add Text To Image", "SHA2"], Images.PNG_HEX, "4ab4d4b6cb22ad700f6cd144c2c8ecad2a094f21a1d1d5d48eb6c8f97417192f89b4512f6a78276d49668ebef5e89c3a4d14860cb79399a0dafce98c92209e07", [[], ["Chef", "Center", "Middle", 0, 0, 16, "Roboto Mono"], []]); + testOp(browser, ["From Hex", "Add Text To Image", "SHA2"], Images.PNG_HEX, "11490db4907516b4d9e256da1ac0b02b561fa7547971e6316a8a0b90c9c66585a11f3145672c6d972b1a221d3bfad9c8a97de7ff77fd9442ebc40f39c1ef9ef7", [[], ["Chef", "Center", "Middle", 0, 0, 16, "Roboto Slab"], []]); + testOp(browser, ["From Hex", "Dither Image", "SHA2"], Images.PNG_HEX, "cbf587a78915cfb14546ba83080b13e5054800802488dd0cb786b8951e7dc0b48f055260917bd0ccfc075e422b9d6aff112948562653995d74e70f0b66367ac3", [[], [], []]); + testOp(browser, ["From Hex", "Generate Image", "SHA2"], Images.PNG_HEX, "2c451762a6c9192fd31dc80765eab3f447be70ea51f6fdb6911ade4d89d4a98bd0a1ff00b08d76aac472faeceb54b66092e3f3be7bbf899bf3e55ca9c96a56aa", [[], [], []]); + testOp(browser, ["From Hex", "Image Hue/Saturation/Lightness", "SHA2"], Images.PNG_HEX, "522dfc0bbef00e05c5d6861a002039fa2952e4bbb7fe8d21d0d538ef6f9d65da82065929b4150dc5b8b49460ee6c9bef7f660b86f8d4e7442a07c61c0a152a4b", [[], [50, 50, 50], []]); + testOp(browser, ["From Hex", "Resize Image", "SHA2"], Images.PNG_HEX, "654bfbf0a0537c901459c4bc22c5fb0bacbf01af775a0733e3a1c46cda5b699bcc4ed85322d813c7bb9b245d62d64425c0766fe03d3d20bc63634e2a4df17626", [[], [64, 64], []]); testOp(browser, "Adler-32 Checksum", "test input", "16160411"); testOp(browser, "Affine Cipher Decode", "test input", "rcqr glnsr", [1, 2]); - testOp(browser, "Affine Cipher Encode", "test input", "njln rbfpn", [2, 1]); + testOp(browser, "Affine Cipher Encode", "test input", "gndg zoujg", [3, 1]); + testOp(browser, "AMF Decode", "\u000A\u0013\u0001\u0003a\u0006\u0009test", /"\$value": "test"/); + testOp(browser, "AMF Encode", '{"a": "test"}', "\u000A\u0013\u0001\u0003a\u0006\u0009test"); testOp(browser, "Analyse hash", "0123456789abcdef", /CRC-64/); testOp(browser, "Atbash Cipher", "test input", "gvhg rmkfg"); // testOp(browser, "Avro to JSON", "test input", "test_output"); - // testOp(browser, "BLAKE2b", "test input", "test_output"); - // testOp(browser, "BLAKE2s", "test input", "test_output"); - // testOp(browser, "BSON deserialise", "test input", "test_output"); - // testOp(browser, "BSON serialise", "test input", "test_output"); + testOp(browser, + [ + "From Hex", "Avro to JSON" + ], + "4f626a0104166176726f2e736368656d6196017b2274797065223a227265636f7264222c226e616d65223a22736d616c6c222c226669656c6473223a5b7b226e616d65223a226e616d65222c2274797065223a22737472696e67227d5d7d146176726f2e636f646563086e756c6c004e0247632e3702e5b75cdab9a62f1541020e0c6d796e616d654e0247632e3702e5b75cdab9a62f1541", + '{"name":"myname"}\n', + [[], [false]] + ); + testOp(browser, "BLAKE2b", "test input", "33ebdc8f38177f3f3f334eeb117a84e11f061bbca4db6b8923e5cec85103f59f415551a5d5a933fdb6305dc7bf84671c2540b463dbfa08ee1895cfaa5bd780b5", ["512", "Hex", { "option": "UTF8", "string": "pass" }]); + testOp(browser, "BLAKE2s", "test input", "defe73d61dfa6e5807e4f9643e159a09ccda6be3c26dcd65f8a9bb38bfc973a7", ["256", "Hex", { "option": "UTF8", "string": "pass" }]); + testOp(browser, "BSON deserialise", "\u0011\u0000\u0000\u0000\u0002a\u0000\u0005\u0000\u0000\u0000test\u0000\u0000", '{\u000A "a": "test"\u000A}'); + testOp(browser, "BSON serialise", '{"a":"test"}', "\u0011\u0000\u0000\u0000\u0002a\u0000\u0005\u0000\u0000\u0000test\u0000\u0000"); // testOp(browser, "Bacon Cipher Decode", "test input", "test_output"); // testOp(browser, "Bacon Cipher Encode", "test input", "test_output"); - // testOp(browser, "Bcrypt", "test input", "test_output"); - // testOp(browser, "Bcrypt compare", "test input", "test_output"); - // testOp(browser, "Bcrypt parse", "test input", "test_output"); - // testOp(browser, "Bifid Cipher Decode", "test input", "test_output"); - // testOp(browser, "Bifid Cipher Encode", "test input", "test_output"); - // testOp(browser, "Bit shift left", "test input", "test_output"); - // testOp(browser, "Bit shift right", "test input", "test_output"); + testOp(browser, "Bcrypt", "test input", /^\$2a\$06\$.{53}$/, [6]); + testOp(browser, "Bcrypt compare", "test input", "Match: test input", ["$2a$05$FCfBSVX7OeRkK.9kQVFCiOYu9XtwtIbePqUiroD1lkASW9q5QClzG"]); + testOp(browser, "Bcrypt parse", "$2a$05$kXWtAIGB/R8VEzInoM5ocOTBtyc0m2YTIwFiBU/0XoW032f9QrkWW", /Rounds: 5/); + testOp(browser, "Bifid Cipher Decode", "qblb tfovy", "test input", ["pass"]); + testOp(browser, "Bifid Cipher Encode", "test input", "qblb tfovy", ["pass"]); + testOp(browser, "Bit shift left", "test input", "\u00E8\u00CA\u00E6\u00E8@\u00D2\u00DC\u00E0\u00EA\u00E8"); + testOp(browser, "Bit shift right", "test input", ":29:\u0010478::"); testOp(browser, "Blowfish Decrypt", "10884e15427dd84ec35204e9c8e921ae", "test_output", [{"option": "Hex", "string": "1234567801234567"}, {"option": "Hex", "string": "0011223344556677"}, "CBC", "Hex", "Raw"]); testOp(browser, "Blowfish Encrypt", "test input", "f0fadbd1d90d774f714248cf26b96410", [{"option": "Hex", "string": "1234567801234567"}, {"option": "Hex", "string": "0011223344556677"}, "CBC", "Raw", "Hex"]); - testOp(browser, ["From Hex", "Blur Image", "To Base64"], Images.PNG_HEX, Images.PNG_BLUR_B64); - // testOp(browser, "Bombe", "test input", "test_output"); + testOp(browser, ["From Hex", "Blur Image", "SHA2"], Images.PNG_HEX, "24f2e89f3e00cc35f551bbc48ea82e76474946ce0282183494d1ca3d3b0012c27b6102c4368ae056dc7fecb6df7886d86ff3d29b7e5965493f30c371eee9a24e"); + testOp(browser, ["From Hex", "Blur Image", "SHA2"], Images.PNG_HEX, "2c49d89fc10c94352c9a19f82de353c37928831d6f976a6b36eb918825a0ba027980801838228a4a0da63f1886e4fa59b6666f992ad2d2b7d4622253dc034052", [[], [5, "Gaussian"], []]); + testOp(browser, ["From Hex", "Sharpen Image", "SHA2"], Images.PNG_HEX, "acc7027642c2eeb67d7356a80ed8a1bdce9adabf656ea1294e47723f506626a7aa41f1660fa844a1e1e83b17180017ab0d5bccd7f6a341692832020dc887eaa5"); + testOp(browser, ["From Hex", "Contain Image", "SHA2"], Images.PNG_HEX, "cb871ad0722d487d56a2b18247b1aa30ecc244eb717e08e23a55cae78759553312dc1717196d7cb9daa04743e57c56fc3901ba92be5a68fb03c377f718e8efe7"); + testOpHtml(browser, "Bombe", "XTSYN WAEUG EZALY NRQIM AMLZX MFUOD AWXLY LZCUZ QOQBQ JLCPK NDDRW F", "table tr:last-child td:first-child", "ECG", ["3-rotor", "LEYJVCNIXWPBQMDRTAKZGFUHOS", "BDFHJLCPRTXVZNYEIWGAKMUSQO} opName - name of operation to be tested, array for multiple ops
* @param {string} input - input text for test
- * @param {Array|Array>} args - aarguments, nested if multiple ops
+ * @param {Array|Array>} [args=[]] - arguments, nested if multiple ops
*/
function bakeOp(browser, opName, input, args=[]) {
- let recipeConfig;
-
- if (typeof(opName) === "string") {
- recipeConfig = JSON.stringify([{
- "op": opName,
- "args": args
- }]);
- } else if (opName instanceof Array) {
- recipeConfig = JSON.stringify(
- opName.map((op, i) => {
- return {
- op: op,
- args: args.length ? args[i] : []
- };
- })
- );
- } else {
- throw new Error("Invalid operation type. Must be string or array of strings. Received: " + typeof(opName));
- }
-
- browser
- .useCss()
- .click("#clr-recipe")
- .click("#clr-io")
- .waitForElementNotPresent("#rec-list li.operation")
- .expect.element("#input-text").to.have.property("value").that.equals("");
-
- browser
- .perform(function() {
- console.log(`Current test: ${opName}`);
- })
- .urlHash("recipe=" + recipeConfig)
- .setValue("#input-text", input)
- .waitForElementPresent("#rec-list li.operation")
- .expect.element("#input-text").to.have.property("value").that.equals(input);
-
- browser
- .waitForElementVisible("#stale-indicator", 5000)
- .pause(100)
- .click("#bake")
- .pause(100)
- .waitForElementPresent("#stale-indicator.hidden", 5000)
- .waitForElementNotVisible("#output-loader", 5000);
+ browser.perform(function() {
+ console.log(`Current test: ${opName}`);
+ });
+ utils.loadRecipe(browser, opName, input, args);
+ browser.waitForElementVisible("#stale-indicator", 5000);
+ utils.bake(browser);
}
/** @function
@@ -436,29 +445,23 @@ function bakeOp(browser, opName, input, args=[]) {
* @param {Browser} browser - Nightwatch client
* @param {string|Array} opName - name of operation to be tested, array for multiple ops
* @param {string} input - input text
- * @param {string} output - expected output
- * @param {Array|Array>} args - arguments, nested if multiple ops
+ * @param {string|RegExp} output - expected output
+ * @param {Array|Array>} [args=[]] - arguments, nested if multiple ops
*/
function testOp(browser, opName, input, output, args=[]) {
-
bakeOp(browser, opName, input, args);
-
- if (typeof output === "string") {
- browser.expect.element("#output-text").to.have.property("value").that.equals(output);
- } else if (output instanceof RegExp) {
- browser.expect.element("#output-text").to.have.property("value").that.matches(output);
- }
+ utils.expectOutput(browser, output, true);
}
/** @function
- * Clears the current recipe and tests a new operation.
+ * Clears the current recipe and tests a new operation with HTML output.
*
* @param {Browser} browser - Nightwatch client
* @param {string|Array} opName - name of operation to be tested array for multiple ops
* @param {string} input - input text
* @param {string} cssSelector - CSS selector for HTML output
- * @param {string} output - expected output
- * @param {Array|Array>} args - arguments, nested if multiple ops
+ * @param {string|RegExp} output - expected output
+ * @param {Array|Array>} [args=[]] - arguments, nested if multiple ops
*/
function testOpHtml(browser, opName, input, cssSelector, output, args=[]) {
bakeOp(browser, opName, input, args);
@@ -469,3 +472,57 @@ function testOpHtml(browser, opName, input, cssSelector, output, args=[]) {
browser.expect.element("#output-html " + cssSelector).text.that.matches(output);
}
}
+
+/** @function
+ * Clears the current recipe and tests a new Image-based operation.
+ *
+ * @param {Browser} browser - Nightwatch client
+ * @param {string|Array} opName - name of operation to be tested array for multiple ops
+ * @param {string} filename - filename of image file from samples directory
+ * @param {Array|Array>} [args=[]] - arguments, nested if multiple ops
+ */
+function testOpImage(browser, opName, filename, args=[]) {
+ browser.perform(function() {
+ console.log(`Current test: ${opName}`);
+ });
+ utils.loadRecipe(browser, opName, "", args);
+ utils.uploadFile(browser, filename);
+ browser.waitForElementVisible("#stale-indicator", 5000);
+ utils.bake(browser);
+
+ browser
+ .waitForElementVisible("#output-html img")
+ .expect.element("#output-html img").to.have.css("width").which.matches(/^[^0]\d*px/);
+}
+
+/** @function
+ * Clears the current recipe and tests a new File-based operation.
+ *
+ * @param {Browser} browser - Nightwatch client
+ * @param {string|Array} opName - name of operation to be tested array for multiple ops
+ * @param {string} filename - filename of file from samples directory
+ * @param {string|boolean} cssSelector - CSS selector for HTML output or false for normal text output
+ * @param {string|RegExp} output - expected output
+ * @param {Array|Array>} [args=[]] - arguments, nested if multiple ops
+ * @param {number} [waitWindow=1000] - The number of milliseconds to wait for the output to be correct
+ */
+function testOpFile(browser, opName, filename, cssSelector, output, args=[], waitWindow=1000) {
+ browser.perform(function() {
+ console.log(`Current test: ${opName}`);
+ });
+ utils.loadRecipe(browser, opName, "", args);
+ utils.uploadFile(browser, filename);
+ browser.pause(100).waitForElementVisible("#stale-indicator", 5000);
+ utils.bake(browser);
+
+ if (!cssSelector) {
+ // Text output
+ utils.expectOutput(browser, output, true, waitWindow);
+ } else if (typeof output === "string") {
+ // HTML output - string match
+ browser.expect.element("#output-html " + cssSelector).text.that.equals(output);
+ } else if (output instanceof RegExp) {
+ // HTML output - RegEx match
+ browser.expect.element("#output-html " + cssSelector).text.that.matches(output);
+ }
+}
diff --git a/tests/browser/browserUtils.js b/tests/browser/browserUtils.js
new file mode 100644
index 00000000..7711c004
--- /dev/null
+++ b/tests/browser/browserUtils.js
@@ -0,0 +1,286 @@
+/**
+ * Utility functions for browser tests.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+/** @function
+ * Clears the recipe and input
+ *
+ * @param {Browser} browser - Nightwatch client
+ */
+function clear(browser) {
+ browser
+ .useCss()
+ .click("#clr-recipe")
+ .click("#clr-io")
+ .waitForElementNotPresent("#rec-list li.operation")
+ .expect.element("#input-text .cm-content").text.that.equals("");
+}
+
+/** @function
+ * Sets the input to the desired string
+ *
+ * @param {Browser} browser - Nightwatch client
+ * @param {string} input - The text to populate the input with
+ * @param {boolean} [type=true] - Whether to type the characters in by using sendKeys,
+ * or to set the value of the editor directly (useful for special characters)
+ */
+function setInput(browser, input, type=true) {
+ clear(browser);
+ if (type) {
+ browser
+ .useCss()
+ .sendKeys("#input-text .cm-content", input)
+ .pause(100);
+ } else {
+ browser.execute(text => {
+ window.app.setInput(text);
+ }, [input]);
+ browser.pause(100);
+ }
+ expectInput(browser, input);
+}
+
+/** @function
+ * Triggers a bake
+ *
+ * @param {Browser} browser - Nightwatch client
+ */
+function bake(browser) {
+ browser
+ // Ensure we're not currently busy
+ .waitForElementNotVisible("#output-loader", 5000)
+ .expect.element("#bake span").text.to.equal("BAKE!");
+
+ browser
+ .click("#bake")
+ .waitForElementNotVisible("#stale-indicator", 5000)
+ .waitForElementNotVisible("#output-loader", 5000);
+}
+
+/** @function
+ * Sets the character encoding in the input or output
+ *
+ * @param {Browser} browser - Nightwatch client
+ * @param {string} io - Either "input" or "output"
+ * @param {string} enc - The encoding to be set
+ */
+function setChrEnc(browser, io, enc) {
+ io = `#${io}-text`;
+ browser
+ .useCss()
+ .waitForElementNotVisible("#snackbar-container", 6000)
+ .click(io + " .chr-enc-value")
+ .waitForElementVisible(io + " .chr-enc-select .cm-status-bar-select-scroll")
+ .click("link text", enc)
+ .waitForElementNotVisible(io + " .chr-enc-select .cm-status-bar-select-scroll")
+ .expect.element(io + " .chr-enc-value").text.that.equals(enc);
+}
+
+/** @function
+ * Sets the end of line sequence in the input or output
+ *
+ * @param {Browser} browser - Nightwatch client
+ * @param {string} io - Either "input" or "output"
+ * @param {string} eol - The sequence to set
+ */
+function setEOLSeq(browser, io, eol) {
+ io = `#${io}-text`;
+ browser
+ .useCss()
+ .waitForElementNotVisible("#snackbar-container", 6000)
+ .click(io + " .eol-value")
+ .waitForElementVisible(io + " .eol-select .cm-status-bar-select-content")
+ .click(`${io} .cm-status-bar-select-content a[data-val=${eol}]`)
+ .waitForElementNotVisible(io + " .eol-select .cm-status-bar-select-content")
+ .expect.element(io + " .eol-value").text.that.equals(eol);
+}
+
+/** @function
+ * Copies whatever is currently selected
+ *
+ * @param {Browser} browser - Nightwatch client
+ */
+function copy(browser) {
+ browser.perform(function() {
+ const actions = this.actions({async: true});
+
+ // Ctrl + Ins used as this works on Windows, Linux and Mac
+ return actions
+ .keyDown(browser.Keys.CONTROL)
+ .keyDown(browser.Keys.INSERT)
+ .keyUp(browser.Keys.INSERT)
+ .keyUp(browser.Keys.CONTROL);
+ });
+}
+
+/** @function
+ * Pastes into the target element
+ *
+ * @param {Browser} browser - Nightwatch client
+ * @param {string} el - Target element selector
+ */
+function paste(browser, el) {
+ browser
+ .click(el)
+ .perform(function() {
+ const actions = this.actions({async: true});
+
+ // Shift + Ins used as this works on Windows, Linux and Mac
+ return actions
+ .keyDown(browser.Keys.SHIFT)
+ .keyDown(browser.Keys.INSERT)
+ .keyUp(browser.Keys.INSERT)
+ .keyUp(browser.Keys.SHIFT);
+ })
+ .pause(100);
+}
+
+/** @function
+ * Loads a recipe and input
+ *
+ * @param {Browser} browser - Nightwatch client
+ * @param {string|Array} opName - name of operation to be loaded, array for multiple ops
+ * @param {string} input - input text for test
+ * @param {Array|Array>} args - arguments, nested if multiple ops
+ */
+function loadRecipe(browser, opName, input, args) {
+ let recipeConfig;
+
+ if (typeof(opName) === "string") {
+ recipeConfig = JSON.stringify([{
+ "op": opName,
+ "args": args
+ }]);
+ } else if (opName instanceof Array) {
+ recipeConfig = JSON.stringify(
+ opName.map((op, i) => {
+ return {
+ op: op,
+ args: args.length ? args[i] : []
+ };
+ })
+ );
+ } else {
+ throw new Error("Invalid operation type. Must be string or array of strings. Received: " + typeof(opName));
+ }
+
+ setInput(browser, input, false);
+ browser
+ .urlHash("recipe=" + recipeConfig)
+ .waitForElementPresent("#rec-list li.operation");
+}
+
+/** @function
+ * Tests whether the output matches a given value
+ *
+ * @param {Browser} browser - Nightwatch client
+ * @param {string|RegExp} expected - The expected output value
+ * @param {boolean} [waitNotNull=false] - Wait for the output to not be empty before testing the value
+ * @param {number} [waitWindow=1000] - The number of milliseconds to wait for the output to be correct
+ */
+function expectOutput(browser, expected, waitNotNull=false, waitWindow=1000) {
+ if (waitNotNull && expected !== "") {
+ browser.waitUntil(async function() {
+ const output = await this.execute(function() {
+ return window.app.manager.output.outputEditorView.state.doc.toString();
+ });
+ return output.length;
+ }, waitWindow);
+ }
+
+ browser.execute(expected => {
+ return window.app.manager.output.outputEditorView.state.doc.toString();
+ }, [expected], function({value}) {
+ if (expected instanceof RegExp) {
+ browser.expect(value).match(expected);
+ } else {
+ browser.expect(value).to.be.equal(expected);
+ }
+ });
+}
+
+/** @function
+ * Tests whether the input matches a given value
+ *
+ * @param {Browser} browser - Nightwatch client
+ * @param {string|RegExp} expected - The expected input value
+ */
+function expectInput(browser, expected) {
+ browser.execute(expected => {
+ return window.app.manager.input.inputEditorView.state.doc.toString();
+ }, [expected], function({value}) {
+ if (expected instanceof RegExp) {
+ browser.expect(value).match(expected);
+ } else {
+ browser.expect(value).to.be.equal(expected);
+ }
+ });
+}
+
+/** @function
+ * Uploads a file using the #open-file input
+ *
+ * @param {Browser} browser - Nightwatch client
+ * @param {string} filename - A path to a file in the samples directory
+ */
+function uploadFile(browser, filename) {
+ const filepath = require("path").resolve(__dirname + "/../samples/" + filename);
+
+ // The file input cannot be interacted with by nightwatch while it is hidden,
+ // so we temporarily expose it for the purposes of this test.
+ browser.execute(() => {
+ document.getElementById("open-file").style.display = "block";
+ });
+ browser
+ .pause(100)
+ .setValue("#open-file", filepath)
+ .pause(100);
+ browser.execute(() => {
+ document.getElementById("open-file").style.display = "none";
+ });
+ browser.waitForElementVisible("#input-text .cm-file-details");
+}
+
+/** @function
+ * Uploads a folder using the #open-folder input
+ *
+ * @param {Browser} browser - Nightwatch client
+ * @param {string} foldername - A path to a folder in the samples directory
+ */
+function uploadFolder(browser, foldername) {
+ const folderpath = require("path").resolve(__dirname + "/../samples/" + foldername);
+
+ // The folder input cannot be interacted with by nightwatch while it is hidden,
+ // so we temporarily expose it for the purposes of this test.
+ browser.execute(() => {
+ document.getElementById("open-folder").style.display = "block";
+ });
+ browser
+ .pause(100)
+ .setValue("#open-folder", folderpath)
+ .pause(500);
+ browser.execute(() => {
+ document.getElementById("open-folder").style.display = "none";
+ });
+ browser.waitForElementVisible("#input-text .cm-file-details");
+}
+
+
+module.exports = {
+ clear: clear,
+ setInput: setInput,
+ bake: bake,
+ setChrEnc: setChrEnc,
+ setEOLSeq: setEOLSeq,
+ copy: copy,
+ paste: paste,
+ loadRecipe: loadRecipe,
+ expectOutput: expectOutput,
+ expectInput: expectInput,
+ uploadFile: uploadFile,
+ uploadFolder: uploadFolder
+};
diff --git a/tests/lib/TestRegister.mjs b/tests/lib/TestRegister.mjs
index 8b687fcc..ea7b934d 100644
--- a/tests/lib/TestRegister.mjs
+++ b/tests/lib/TestRegister.mjs
@@ -74,9 +74,7 @@ class TestRegister {
const result = await chef.bake(
test.input,
test.recipeConfig,
- {},
- 0,
- false
+ { returnType: "string" }
);
const ret = {
diff --git a/tests/node/index.mjs b/tests/node/index.mjs
index f6abba40..f872f8f4 100644
--- a/tests/node/index.mjs
+++ b/tests/node/index.mjs
@@ -23,6 +23,7 @@ import "./tests/Dish.mjs";
import "./tests/NodeDish.mjs";
import "./tests/Utils.mjs";
import "./tests/Categories.mjs";
+import "./tests/lib/BigIntUtils.mjs";
const testStatus = {
allTestsPassing: true,
diff --git a/tests/node/tests/Utils.mjs b/tests/node/tests/Utils.mjs
index 8dbf37ae..5ee7c936 100644
--- a/tests/node/tests/Utils.mjs
+++ b/tests/node/tests/Utils.mjs
@@ -20,4 +20,10 @@ TestRegister.addApiTests([
assert.equal(Utils.parseEscapedChars("\\\\\\'"), "\\'");
}),
+ it("Utils: should replace delete character", () => {
+ assert.equal(
+ Utils.printable("\x7e\x7f\x80\xa7", false, true),
+ "\x7e...",
+ );
+ }),
]);
diff --git a/tests/node/tests/lib/BigIntUtils.mjs b/tests/node/tests/lib/BigIntUtils.mjs
new file mode 100644
index 00000000..f745f91b
--- /dev/null
+++ b/tests/node/tests/lib/BigIntUtils.mjs
@@ -0,0 +1,150 @@
+import TestRegister from "../../../lib/TestRegister.mjs";
+import { parseBigInt, egcd, modPow } from "../../../../src/core/lib/BigIntUtils.mjs";
+import it from "../../assertionHandler.mjs";
+import assert from "assert";
+
+TestRegister.addApiTests([
+ // ===== parseBigInt tests =====
+ it("BigIntUtils: parseBigInt - decimal number", () => {
+ const value = parseBigInt("1", "test value");
+ assert.deepStrictEqual(value, BigInt("1"));
+ }),
+
+ it("BigIntUtils: parseBigInt - large decimal", () => {
+ const value = parseBigInt("123456789012345678901234567890", "test value");
+ assert.deepStrictEqual(value, BigInt("123456789012345678901234567890"));
+ }),
+
+ it("BigIntUtils: parseBigInt - hexadecimal lowercase", () => {
+ const value = parseBigInt("0xff", "test value");
+ assert.deepStrictEqual(value, BigInt("255"));
+ }),
+
+ it("BigIntUtils: parseBigInt - hexadecimal uppercase", () => {
+ const value = parseBigInt("0xFF", "test value");
+ assert.deepStrictEqual(value, BigInt("255"));
+ }),
+
+ it("BigIntUtils: parseBigInt - large hexadecimal", () => {
+ const value = parseBigInt("0x123456789ABCDEF", "test value");
+ assert.deepStrictEqual(value, BigInt("0x123456789ABCDEF"));
+ }),
+
+ it("BigIntUtils: parseBigInt - whitespace trimming", () => {
+ const value = parseBigInt(" 42 ", "test value");
+ assert.deepStrictEqual(value, BigInt("42"));
+ }),
+
+ it("BigIntUtils: parseBigInt - invalid input (text)", () => {
+ assert.throws(() => parseBigInt("test", "test value"), {
+ name: "Error",
+ message: "test value must be decimal or hex (0x...)"
+ });
+ }),
+
+ it("BigIntUtils: parseBigInt - invalid input (hex without prefix)", () => {
+ assert.throws(() => parseBigInt("FF", "test value"), {
+ name: "Error",
+ message: "test value must be decimal or hex (0x...)"
+ });
+ }),
+
+ it("BigIntUtils: parseBigInt - invalid input (mixed)", () => {
+ assert.throws(() => parseBigInt("12abc", "test value"), {
+ name: "Error",
+ message: "test value must be decimal or hex (0x...)"
+ });
+ }),
+
+ // ===== egcd tests =====
+ it("BigIntUtils: egcd - basic coprime", () => {
+ const a = BigInt("36");
+ const b = BigInt("48");
+ const gcd = BigInt("12");
+ const bezout1 = BigInt("-1");
+ const bezout2 = BigInt("1");
+ assert.deepStrictEqual(egcd(a, b), [gcd, bezout1, bezout2]);
+ }),
+
+ it("BigIntUtils: egcd - coprime numbers", () => {
+ const [g, x, y] = egcd(BigInt("3"), BigInt("11"));
+ assert.strictEqual(g, BigInt("1"));
+ // Verify Bézout identity: a*x + b*y = gcd
+ assert.strictEqual(BigInt("3") * x + BigInt("11") * y, g);
+ }),
+
+ it("BigIntUtils: egcd - non-coprime numbers", () => {
+ const [g, x, y] = egcd(BigInt("240"), BigInt("46"));
+ assert.strictEqual(g, BigInt("2"));
+ // Verify Bézout identity
+ assert.strictEqual(BigInt("240") * x + BigInt("46") * y, g);
+ }),
+
+ it("BigIntUtils: egcd - with zero", () => {
+ const [g, x, y] = egcd(BigInt("17"), BigInt("0"));
+ assert.strictEqual(g, BigInt("17"));
+ assert.strictEqual(x, BigInt("1"));
+ assert.strictEqual(y, BigInt("0"));
+ }),
+
+ it("BigIntUtils: egcd - identical numbers", () => {
+ const [g, x, y] = egcd(BigInt("42"), BigInt("42"));
+ assert.strictEqual(g, BigInt("42"));
+ // Verify Bézout identity
+ assert.strictEqual(BigInt("42") * x + BigInt("42") * y, g);
+ }),
+
+ it("BigIntUtils: egcd - large numbers", () => {
+ const a = BigInt("123456789012345678901234567890");
+ const b = BigInt("987654321098765432109876543210");
+ const [g, x, y] = egcd(a, b);
+ // Verify Bézout identity
+ assert.strictEqual(a * x + b * y, g);
+ }),
+
+ // ===== modPow tests =====
+ it("BigIntUtils: modPow - basic", () => {
+ // 2^10 mod 1000 = 1024 mod 1000 = 24
+ const result = modPow(BigInt("2"), BigInt("10"), BigInt("1000"));
+ assert.strictEqual(result, BigInt("24"));
+ }),
+
+ it("BigIntUtils: modPow - RSA-like example", () => {
+ // Common RSA public exponent
+ const base = BigInt("123456789");
+ const exp = BigInt("65537");
+ const mod = BigInt("999999999999");
+ const result = modPow(base, exp, mod);
+ // Result should be less than modulus
+ assert(result < mod);
+ assert(result >= BigInt("0"));
+ }),
+
+ it("BigIntUtils: modPow - exponent zero", () => {
+ // Any number^0 = 1
+ const result = modPow(BigInt("999"), BigInt("0"), BigInt("100"));
+ assert.strictEqual(result, BigInt("1"));
+ }),
+
+ it("BigIntUtils: modPow - base zero", () => {
+ // 0^n = 0
+ const result = modPow(BigInt("0"), BigInt("5"), BigInt("100"));
+ assert.strictEqual(result, BigInt("0"));
+ }),
+
+ it("BigIntUtils: modPow - large exponent", () => {
+ // Test with very large exponent (efficient algorithm should handle this)
+ const result = modPow(BigInt("3"), BigInt("1000000"), BigInt("1000000007"));
+ assert(result >= BigInt("0"));
+ assert(result < BigInt("1000000007"));
+ }),
+
+ it("BigIntUtils: modPow - modular inverse verification", () => {
+ // If a*x . 1 (mod m), then modPow(a, 1, m) * x . 1 (mod m)
+ const a = BigInt("3");
+ const m = BigInt("11");
+ const x = BigInt("4"); // inverse of 3 mod 11
+ const result = modPow(a, BigInt("1"), m) * x % m;
+ assert.strictEqual(result, BigInt("1"));
+ }),
+]);
diff --git a/tests/node/tests/nodeApi.mjs b/tests/node/tests/nodeApi.mjs
index 0d4a04a4..92d4d991 100644
--- a/tests/node/tests/nodeApi.mjs
+++ b/tests/node/tests/nodeApi.mjs
@@ -119,7 +119,7 @@ TestRegister.addApiTests([
assert.strictEqual(result[0].module, "Ciphers");
assert.strictEqual(result[0].inputType, "string");
assert.strictEqual(result[0].outputType, "string");
- assert.strictEqual(result[0].description, "Triple DES applies DES three times to each block to increase key size.
Key: Triple DES uses a key length of 24 bytes (192 bits).
DES uses a key length of 8 bytes (64 bits).
IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
Padding: In CBC and ECB mode, PKCS#7 padding will be used as a default."); + assert.strictEqual(result[0].description, "Triple DES applies DES three times to each block to increase key size.
Key: Triple DES uses a key length of 24 bytes (192 bits).
IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
Padding: In CBC and ECB mode, PKCS#7 padding will be used as a default."); assert.strictEqual(result[0].args.length, 5); }), @@ -136,7 +136,7 @@ TestRegister.addApiTests([ it("chef.help: returns multiple results", () => { const result = chef.help("base 64"); - assert.strictEqual(result.length, 11); + assert.strictEqual(result.length, 13); }), it("chef.help: looks in description for matches too", () => { @@ -345,6 +345,42 @@ TestRegister.addApiTests([ assert.strictEqual(result.toString(), "begin_something_aaaaaaaaaaaaaa_end_something"); }), + it("chef.bake: should accept operation names from Chef Website which contain forward slash", () => { + const result = chef.bake("I'll have the test salmon", [ + { "op": "Find / Replace", + "args": [{ "option": "Regex", "string": "test" }, "good", true, false, true, false]} + ]); + assert.strictEqual(result.toString(), "I'll have the good salmon"); + }), + + it("chef.bake: should accept operation names from Chef Website which contain a hyphen", () => { + const result = chef.bake("I'll have the test salmon", [ + { "op": "Adler-32 Checksum", + "args": [] } + ]); + assert.strictEqual(result.toString(), "6e4208f8"); + }), + + it("chef.bake: should accept operation names from Chef Website which contain a period", () => { + const result = chef.bake("30 13 02 01 05 16 0e 41 6e 79 62 6f 64 79 20 74 68 65 72 65 3f", [ + { "op": "Parse ASN.1 hex string", + "args": [0, 32] } + ]); + assert.strictEqual(result.toString(), `SEQUENCE + INTEGER 05 + IA5String 'Anybody there?' +`); + }), + + it("Excluded operations: throw a sensible error when you try and call one", () => { + try { + chef.fork(); + } catch (e) { + assert.strictEqual(e.type, "ExcludedOperationError"); + assert.strictEqual(e.message, "Sorry, the Fork operation is not available in the Node.js version of CyberChef."); + } + }), + it("chef.bake: cannot accept flowControl operations in recipe", () => { assert.throws(() => chef.bake("some input", "magic"), { name: "TypeError", diff --git a/tests/node/tests/operations.mjs b/tests/node/tests/operations.mjs index 783bd00a..a97f5ccb 100644 --- a/tests/node/tests/operations.mjs +++ b/tests/node/tests/operations.mjs @@ -45,10 +45,10 @@ TestRegister.addApiTests([ const result = chef.ADD("sample input", { key: { string: "some key", - option: "Hex" + option: "utf8" } }); - assert.equal(result.toString(), "aO[^ZS\u000eW\\^cb"); + assert.equal(result.toString(), "\xe6\xd0\xda\xd5\x8c\xd0\x85\xe2\xe1\xdf\xe2\xd9"); }), @@ -121,10 +121,10 @@ Tiger-128`; const result = chef.AND("Scot-free", { key: { string: "Raining Cats and Dogs", - option: "Hex", + option: "utf8", } }); - assert.strictEqual(result.toString(), "\u0000\"M$(D E"); + assert.strictEqual(result.toString(), "Raid)fb A"); }), it("atBash Cipher", () => { @@ -305,16 +305,6 @@ Full hash: $2a$10$ODeP1.6fMsb.ENk2ngPUCO7qTGVPyHA9TqDVcyupyed8FjsiF65L6`; assert.strictEqual(result.toString(), "2"); }), - it("CRC16 Checksum", () => { - const result = chef.CRC16Checksum("Rain on Your Parade"); - assert.strictEqual(result.toString(), "db1c"); - }), - - it("CRC32 Checksum", () => { - const result = chef.CRC32Checksum("Rain on Your Parade"); - assert.strictEqual(result.toString(), "e902f76c"); - }), - it("CSS Beautify", () => { const result = chef.CSSBeautify("header {color:black;padding:3rem;}"); const expected = `header { @@ -371,10 +361,10 @@ color: white; }, salt: { string: "Market", - option: "Hex", + option: "utf8", }, }); - assert.strictEqual(result.toString(), "7c21a9f5063a4d62fb1050068245c181"); + assert.strictEqual(result.toString(), "4930d5d200e80f18c96b5550d13c6af8"); }), it("Derive PBKDF2 Key", () => { @@ -432,7 +422,7 @@ color: white; it("Disassemble x86", () => { const result = chef.disassembleX86(chef.toBase64("one two three")); const expected = `0000000000000000 0000 ADD BYTE PTR [RAX],AL\r -0000000000000002 0B250000000B OR ESP,DWORD PTR [0000000-F4FFFFF8]\r +0000000000000002 0B250000000B OR ESP,DWORD PTR [000000000B000008]\r `; assert.strictEqual(result.toString(), expected); }), @@ -575,12 +565,11 @@ Top Drawer`, { }), it("Generate HOTP", () => { - const result = chef.generateHOTP("Cut The Mustard", { - name: "colonel", + const result = chef.generateHOTP("JBSWY3DPEHPK3PXP", { }); - const expected = `URI: otpauth://hotp/colonel?secret=IN2XIICUNBSSATLVON2GC4TE + const expected = `URI: otpauth://hotp/?secret=JBSWY3DPEHPK3PXP&algorithm=SHA1&digits=6&counter=0 -Password: 034148`; +Password: 282760`; assert.strictEqual(result.toString(), expected); }), @@ -591,10 +580,24 @@ Password: 034148`; assert.strictEqual(result.toString().substr(0, 37), "-----BEGIN PGP PRIVATE KEY BLOCK-----"); }), - it("Generate UUID", () => { - const result = chef.generateUUID(); - assert.ok(result.toString()); - assert.strictEqual(result.toString().length, 36); + ...[1, 3, 4, 5, 6, 7].map(version => it(`Generate UUID v${version}`, () => { + const result = chef.generateUUID("", { "version": `v${version}` }).toString(); + assert.ok(result); + assert.strictEqual(result.length, 36); + })), + + ...[1, 3, 4, 5, 6, 7].map(version => it(`Analyze UUID v${version}`, () => { + const uuid = chef.generateUUID("", { "version": `v${version}` }).toString(); + const result = chef.analyseUUID(uuid).toString(); + assert.ok(result.startsWith(`Version:\n${version}\n`), `Expected output to start with "Version:\\n${version}\\n", got: ${result}`); + })), + + it("Generate UUID using defaults", () => { + const uuid = chef.generateUUID(); + assert.ok(uuid); + + const analysis = chef.analyseUUID(uuid).toString(); + assert.ok(analysis.startsWith("Version:\n4\n"), `Expected output to start with "Version:\\n4\\n", got: ${analysis}`); }), it("Gzip, Gunzip", () => { @@ -635,6 +638,10 @@ WWFkYSBZYWRh\r assert.strictEqual(chef.keccak("Flea Market").toString(), "c2a06880b19e453ee5440e8bd4c2024bedc15a6630096aa3f609acfd2b8f15f27cd293e1cc73933e81432269129ce954a6138889ce87831179d55dcff1cc7587"); }), + it("LZNT1 Decompress", () => { + assert.strictEqual(chef.LZNT1Decompress("\x1a\xb0\x00compress\x00edtestda\x04ta\x07\x88alot").toString(), "compressedtestdatacompressedalot"); + }), + it("MD6", () => { assert.strictEqual(chef.MD6("Head Over Heels", {key: "arty"}).toString(), "d8f7fe4931fbaa37316f76283d5f615f50ddd54afdc794b61da522556aee99ad"); }), @@ -859,13 +866,15 @@ pCGTErs= }), it("SQL Beautify", () => { - const result = chef.SQLBeautify(`SELECT MONTH, ID, RAIN_I, TEMP_F -FROM STATS;`); - const expected = `SELECT MONTH, - ID, - RAIN_I, - TEMP_F -FROM STATS;`; + const result = chef.SQLBeautify(`SELECT MONTH, ID, RAIN_I, TEMP_F FROM STATS;`); + const expected = +`SELECT + MONTH, + ID, + RAIN_I, + TEMP_F +FROM + STATS;`; assert.strictEqual(result.toString(), expected); }), diff --git a/tests/operations/index.mjs b/tests/operations/index.mjs index 141f35de..71221cc1 100644 --- a/tests/operations/index.mjs +++ b/tests/operations/index.mjs @@ -4,7 +4,7 @@ * @author john [john19696@protonmail.com] * @author tlwr [toby@toby.codes] * @author n1474335 [n1474335@gmail.com] -* @copyright Crown Copyright 2022 +* @copyright Crown Copyright 2026 * @license Apache-2.0 */ @@ -14,31 +14,42 @@ import { } from "../lib/utils.mjs"; import TestRegister from "../lib/TestRegister.mjs"; +import "./tests/A1Z26CipherDecode.mjs"; +import "./tests/AESKeyWrap.mjs"; +import "./tests/AlternatingCaps.mjs"; +import "./tests/AnalyseUUID.mjs"; import "./tests/AvroToJSON.mjs"; import "./tests/BCD.mjs"; import "./tests/BLAKE2b.mjs"; import "./tests/BLAKE2s.mjs"; +import "./tests/BLAKE3.mjs"; import "./tests/BSON.mjs"; import "./tests/BaconCipher.mjs"; +import "./tests/Base32.mjs"; import "./tests/Base45.mjs"; import "./tests/Base58.mjs"; import "./tests/Base62.mjs"; import "./tests/Base64.mjs"; import "./tests/Base85.mjs"; +import "./tests/Base92.mjs"; +import "./tests/Bech32.mjs"; import "./tests/BitwiseOp.mjs"; import "./tests/Bombe.mjs"; import "./tests/ByteRepr.mjs"; import "./tests/CBORDecode.mjs"; import "./tests/CBOREncode.mjs"; +import "./tests/CMAC.mjs"; +import "./tests/CRCChecksum.mjs"; import "./tests/CSV.mjs"; import "./tests/CaesarBoxCipher.mjs"; +import "./tests/CaretMdecode.mjs"; import "./tests/CartesianProduct.mjs"; import "./tests/CetaceanCipherDecode.mjs"; import "./tests/CetaceanCipherEncode.mjs"; +import "./tests/ChaCha.mjs"; import "./tests/ChangeIPFormat.mjs"; import "./tests/CharEnc.mjs"; import "./tests/Charts.mjs"; -import "./tests/Checksum.mjs"; import "./tests/CipherSaber2.mjs"; import "./tests/Ciphers.mjs"; import "./tests/Code.mjs"; @@ -47,79 +58,137 @@ import "./tests/Comment.mjs"; import "./tests/Compress.mjs"; import "./tests/ConditionalJump.mjs"; import "./tests/ConvertCoordinateFormat.mjs"; +import "./tests/ConvertLeetSpeak.mjs"; import "./tests/ConvertToNATOAlphabet.mjs"; import "./tests/Crypt.mjs"; import "./tests/DateTime.mjs"; import "./tests/DefangIP.mjs"; +import "./tests/DisassembleARM.mjs"; +import "./tests/DropNthBytes.mjs"; +import "./tests/ECDSA.mjs"; import "./tests/ELFInfo.mjs"; import "./tests/Enigma.mjs"; +import "./tests/ExtractAudioMetadata.mjs"; import "./tests/ExtractEmailAddresses.mjs"; +import "./tests/ExtractHashes.mjs"; +import "./tests/ExtractIPAddresses.mjs"; +import "./tests/Fernet.mjs"; +import "./tests/FileTree.mjs"; +import "./tests/FlaskSession.mjs"; +import "./tests/FletcherChecksum.mjs"; +import "./tests/Float.mjs"; import "./tests/Fork.mjs"; import "./tests/FromDecimal.mjs"; -import "./tests/FromGeohash.mjs"; +import "./tests/GOST.mjs"; +import "./tests/GenerateAllChecksums.mjs"; +import "./tests/GenerateAllHashes.mjs"; +import "./tests/GenerateDeBruijnSequence.mjs"; +import "./tests/GenerateQRCode.mjs"; import "./tests/GetAllCasings.mjs"; import "./tests/Gunzip.mjs"; import "./tests/Gzip.mjs"; import "./tests/HASSH.mjs"; +import "./tests/HKDF.mjs"; import "./tests/Hash.mjs"; import "./tests/HaversineDistance.mjs"; import "./tests/Hex.mjs"; import "./tests/Hexdump.mjs"; +import "./tests/IPv6Transition.mjs"; import "./tests/Image.mjs"; import "./tests/IndexOfCoincidence.mjs"; import "./tests/JA3Fingerprint.mjs"; import "./tests/JA3SFingerprint.mjs"; +import "./tests/JA4.mjs"; import "./tests/JSONBeautify.mjs"; import "./tests/JSONMinify.mjs"; import "./tests/JSONtoCSV.mjs"; +import "./tests/JSONtoYAML.mjs"; +import "./tests/JWK.mjs"; import "./tests/JWTDecode.mjs"; import "./tests/JWTSign.mjs"; import "./tests/JWTVerify.mjs"; +import "./tests/Jq.mjs"; +import "./tests/Jsonata.mjs"; import "./tests/Jump.mjs"; import "./tests/LS47.mjs"; +import "./tests/LZNT1Decompress.mjs"; import "./tests/LZString.mjs"; +import "./tests/LevenshteinDistance.mjs"; import "./tests/Lorenz.mjs"; import "./tests/LuhnChecksum.mjs"; +import "./tests/MIMEDecoding.mjs"; import "./tests/MS.mjs"; import "./tests/Magic.mjs"; import "./tests/Media.mjs"; +import "./tests/Modhex.mjs"; import "./tests/MorseCode.mjs"; import "./tests/MultipleBombe.mjs"; +import "./tests/MurmurHash3.mjs"; +import "./tests/NTLM.mjs"; import "./tests/NetBIOS.mjs"; import "./tests/NormaliseUnicode.mjs"; import "./tests/OTP.mjs"; import "./tests/PEMtoHex.mjs"; import "./tests/PGP.mjs"; import "./tests/PHP.mjs"; +import "./tests/PHPSerialize.mjs"; +import "./tests/ParityBit.mjs"; +import "./tests/ParseCSR.mjs"; +import "./tests/ParseEthernetFrame.mjs"; import "./tests/ParseIPRange.mjs"; import "./tests/ParseObjectIDTimestamp.mjs"; import "./tests/ParseQRCode.mjs"; import "./tests/ParseSSHHostKey.mjs"; import "./tests/ParseTCP.mjs"; +import "./tests/ParseTLSRecord.mjs"; import "./tests/ParseTLV.mjs"; import "./tests/ParseUDP.mjs"; +import "./tests/ParseX509CRL.mjs"; import "./tests/PowerSet.mjs"; import "./tests/Protobuf.mjs"; +import "./tests/PubKeyFromCert.mjs"; +import "./tests/PubKeyFromPrivKey.mjs"; +import "./tests/RAKE.mjs"; +import "./tests/RC6.mjs"; import "./tests/RSA.mjs"; +import "./tests/Rabbit.mjs"; import "./tests/Regex.mjs"; import "./tests/Register.mjs"; +import "./tests/RegularExpression.mjs"; +import "./tests/RenderMarkdown.mjs"; +import "./tests/RisonEncodeDecode.mjs"; import "./tests/Rotate.mjs"; import "./tests/SIGABA.mjs"; +import "./tests/SM2.mjs"; import "./tests/SM4.mjs"; +import "./tests/SQLBeautify.mjs"; +import "./tests/Salsa20.mjs"; import "./tests/SeqUtils.mjs"; import "./tests/SetDifference.mjs"; import "./tests/SetIntersection.mjs"; import "./tests/SetUnion.mjs"; +import "./tests/Shuffle.mjs"; import "./tests/SplitColourChannels.mjs"; import "./tests/StrUtils.mjs"; +import "./tests/StripIPv4Header.mjs"; +import "./tests/StripTCPHeader.mjs"; +import "./tests/StripUDPHeader.mjs"; import "./tests/Subsection.mjs"; +import "./tests/SwapCase.mjs"; import "./tests/SymmetricDifference.mjs"; +import "./tests/TakeNthBytes.mjs"; +import "./tests/Template.mjs"; import "./tests/TextEncodingBruteForce.mjs"; +import "./tests/TextIntegerConverter.mjs"; import "./tests/ToFromInsensitiveRegex.mjs"; -import "./tests/ToGeohash.mjs"; import "./tests/TranslateDateTimeFormat.mjs"; import "./tests/Typex.mjs"; +import "./tests/URLEncodeDecode.mjs"; +import "./tests/UnescapeString.mjs"; import "./tests/Unicode.mjs"; +import "./tests/XORChecksum.mjs"; +import "./tests/XSalsa20.mjs"; +import "./tests/XXTEA.mjs"; import "./tests/YARA.mjs"; // Cannot test operations that use the File type yet diff --git a/tests/operations/tests/A1Z26CipherDecode.mjs b/tests/operations/tests/A1Z26CipherDecode.mjs new file mode 100644 index 00000000..97020e0b --- /dev/null +++ b/tests/operations/tests/A1Z26CipherDecode.mjs @@ -0,0 +1,33 @@ +/** + * A1Z26 Cipher Decode tests + * + * @author brick-pixel + * @copyright Crown Copyright 2026 + * @license Apache-2.0 + */ +import TestRegister from "../../lib/TestRegister.mjs"; + +TestRegister.addTests([ + { + "name": "A1Z26 Cipher Decode: basic decode", + "input": "8 5 12 12 15", + "expectedOutput": "hello", + "recipeConfig": [ + { + "op": "A1Z26 Cipher Decode", + "args": ["Space"] + } + ] + }, + { + "name": "A1Z26 Cipher Decode: empty input returns empty string", + "input": "", + "expectedOutput": "", + "recipeConfig": [ + { + "op": "A1Z26 Cipher Decode", + "args": ["Space"] + } + ] + } +]); diff --git a/tests/operations/tests/AESKeyWrap.mjs b/tests/operations/tests/AESKeyWrap.mjs new file mode 100644 index 00000000..bca36a40 --- /dev/null +++ b/tests/operations/tests/AESKeyWrap.mjs @@ -0,0 +1,324 @@ +/** + * @author mikecat + * @copyright Crown Copyright 2022 + * @license Apache-2.0 + */ +import TestRegister from "../../lib/TestRegister.mjs"; + +TestRegister.addTests([ + { + "name": "AES Key Wrap: RFC Test Vector, 128-bit data, 128-bit KEK", + "input": "00112233445566778899aabbccddeeff", + "expectedOutput": "1fa68b0a8112b447aef34bd8fb5a7b829d3e862371d2cfe5", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: RFC Test Vector, 128-bit data, 192-bit KEK", + "input": "00112233445566778899aabbccddeeff", + "expectedOutput": "96778b25ae6ca435f92b5b97c050aed2468ab8a17ad84e5d", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f1011121314151617"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: RFC Test Vector, 128-bit data, 256-bit KEK", + "input": "00112233445566778899aabbccddeeff", + "expectedOutput": "64e8c3f9ce0f5ba263e9777905818a2a93c8191e7d6e8ae7", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: RFC Test Vector, 192-bit data, 192-bit KEK", + "input": "00112233445566778899aabbccddeeff0001020304050607", + "expectedOutput": "031d33264e15d33268f24ec260743edce1c6c7ddee725a936ba814915c6762d2", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f1011121314151617"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: RFC Test Vector, 192-bit data, 256-bit KEK", + "input": "00112233445566778899aabbccddeeff0001020304050607", + "expectedOutput": "a8f9bc1612c68b3ff6e6f4fbe30e71e4769c8b80a32cb8958cd5d17d6b254da1", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: RFC Test Vector, 256-bit data, 256-bit KEK", + "input": "00112233445566778899aabbccddeeff000102030405060708090a0b0c0d0e0f", + "expectedOutput": "28c9f404c4b810f4cbccb35cfb87f8263f5786e2d80ed326cbc7f0e71a99f43bfb988b9b7a02dd21", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: RFC Test Vector, 128-bit data, 128-bit KEK", + "input": "1fa68b0a8112b447aef34bd8fb5a7b829d3e862371d2cfe5", + "expectedOutput": "00112233445566778899aabbccddeeff", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: RFC Test Vector, 128-bit data, 192-bit KEK", + "input": "96778b25ae6ca435f92b5b97c050aed2468ab8a17ad84e5d", + "expectedOutput": "00112233445566778899aabbccddeeff", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f1011121314151617"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: RFC Test Vector, 128-bit data, 256-bit KEK", + "input": "64e8c3f9ce0f5ba263e9777905818a2a93c8191e7d6e8ae7", + "expectedOutput": "00112233445566778899aabbccddeeff", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: RFC Test Vector, 192-bit data, 192-bit KEK", + "input": "031d33264e15d33268f24ec260743edce1c6c7ddee725a936ba814915c6762d2", + "expectedOutput": "00112233445566778899aabbccddeeff0001020304050607", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f1011121314151617"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: RFC Test Vector, 192-bit data, 256-bit KEK", + "input": "a8f9bc1612c68b3ff6e6f4fbe30e71e4769c8b80a32cb8958cd5d17d6b254da1", + "expectedOutput": "00112233445566778899aabbccddeeff0001020304050607", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: RFC Test Vector, 256-bit data, 256-bit KEK", + "input": "28c9f404c4b810f4cbccb35cfb87f8263f5786e2d80ed326cbc7f0e71a99f43bfb988b9b7a02dd21", + "expectedOutput": "00112233445566778899aabbccddeeff000102030405060708090a0b0c0d0e0f", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: invalid KEK length", + "input": "00112233445566778899aabbccddeeff", + "expectedOutput": "KEK must be either 16, 24, or 32 bytes (currently 10 bytes)", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "00010203040506070809"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: invalid IV length", + "input": "00112233445566778899aabbccddeeff", + "expectedOutput": "IV must be 8 bytes (currently 6 bytes)", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: input length not multiple of 8", + "input": "00112233445566778899aabbccddeeff0102", + "expectedOutput": "input must be 8n (n>=2) bytes (currently 18 bytes)", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: input too short", + "input": "0011223344556677", + "expectedOutput": "input must be 8n (n>=2) bytes (currently 8 bytes)", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: invalid KEK length", + "input": "1fa68b0a8112b447aef34bd8fb5a7b829d3e862371d2cfe5", + "expectedOutput": "KEK must be either 16, 24, or 32 bytes (currently 10 bytes)", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "00010203040506070809"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: invalid IV length", + "input": "1fa68b0a8112b447aef34bd8fb5a7b829d3e862371d2cfe5", + "expectedOutput": "IV must be 8 bytes (currently 6 bytes)", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: input length not multiple of 8", + "input": "1fa68b0a8112b447aef34bd8fb5a7b829d3e862371d2cfe5e621", + "expectedOutput": "input must be 8n (n>=3) bytes (currently 26 bytes)", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: input too short", + "input": "1fa68b0a8112b447aef34bd8fb5a7b82", + "expectedOutput": "input must be 8n (n>=3) bytes (currently 16 bytes)", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: corrupted input", + "input": "1fa68b0a8112b447aef34bd8fb5a7b829d3e862371d2cfe6", + "expectedOutput": "IV mismatch", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, +]); diff --git a/tests/operations/tests/AlternatingCaps.mjs b/tests/operations/tests/AlternatingCaps.mjs new file mode 100644 index 00000000..b23768eb --- /dev/null +++ b/tests/operations/tests/AlternatingCaps.mjs @@ -0,0 +1,19 @@ +/* @author sw5678 + * @copyright Crown Copyright 2024 + * @license Apache-2.0 + */ +import TestRegister from "../../lib/TestRegister.mjs"; + +TestRegister.addTests([ + { + "name": "AlternatingCaps: Basic Example", + "input": "Hello, world!", + "expectedOutput": "hElLo, WoRlD!", + "recipeConfig": [ + { + "op": "Alternating Caps", + "args": [] + }, + ], + } +]); diff --git a/tests/operations/tests/AnalyseUUID.mjs b/tests/operations/tests/AnalyseUUID.mjs new file mode 100644 index 00000000..89118421 --- /dev/null +++ b/tests/operations/tests/AnalyseUUID.mjs @@ -0,0 +1,66 @@ +/** + * Analyse UUID tests + * + * @author ko80240 [csk.dev@proton.me] + * @copyright Crown Copyright 2023 + * @license Apache-2.0 + */ +import TestRegister from "../../lib/TestRegister.mjs"; + +TestRegister.addTests([ + { + "name": "Analyse UUID: v1 UUID extracts timestamp, clock, and node", + "input": "cefa1760-28ee-11f1-9f95-1fb76af3e239", + "expectedOutput": "Version:\n1\n\nTimestamp:\n1774514156502\n\nTimestamp (ISO):\n2026-03-26T08:35:56.502Z\n\nNode:\n1F:B7:6A:F3:E2:39\n\nClock:\n8085\n\nUUID Integer:\n275119515460318071558429785403790975545", + "recipeConfig": [ + { + "op": "Analyse UUID", + "args": [true] + } + ] + }, + { + "name": "Analyse UUID: v7 UUID extracts timestamp, randA, and randB", + "input": "019d294a-af64-7728-9524-26da08f50708", + "expectedOutput": "Version:\n7\n\nTimestamp:\n1774514253668\n\nTimestamp (ISO):\n2026-03-26T08:37:33.668Z\n\nRand A:\n1832\n\nRand B:\n952426DA08F50708\n\nUUID Integer:\n2145256098533991595556290452700595976", + "recipeConfig": [ + { + "op": "Analyse UUID", + "args": [true] + } + ] + }, + { + "name": "Analyse UUID: v4 UUID should show no metadata - not possible", + "input": "f47ac10b-58cc-4372-a567-0e02b2c3d479", + "expectedOutput": "Version:\n4\n\nNo metadata available. Only versions 1, 6, 7 are supported.\n\nUUID Integer:\n324969006592305634633390616021200786553", + "recipeConfig": [ + { + "op": "Analyse UUID", + "args": [true] + } + ] + }, + { + "name": "Analyse UUID: if the 'Include Metadata' option is false it should return not metadata", + "input": "cefa1760-28ee-11f1-9f95-1fb76af3e239", + "expectedOutput": "Version:\n1\n\nUUID Integer:\n275119515460318071558429785403790975545", + "recipeConfig": [ + { + "op": "Analyse UUID", + "args": [false] + } + ] + }, + { + "name": "Analyse UUID: invalid UUID should return error message", + "input": "not-a-uuid", + "expectedOutput": "Invalid UUID", + "recipeConfig": [ + { + "op": "Analyse UUID", + "args": [true] + } + ] + } +]); diff --git a/tests/operations/tests/BLAKE3.mjs b/tests/operations/tests/BLAKE3.mjs new file mode 100644 index 00000000..42cb4dc1 --- /dev/null +++ b/tests/operations/tests/BLAKE3.mjs @@ -0,0 +1,55 @@ +/** + * BLAKE3 tests. + * @author xumptex [xumptex@outlook.fr] + * @copyright Crown Copyright 2025 + * @license Apache-2.0 + */ +import TestRegister from "../../lib/TestRegister.mjs"; + +TestRegister.addTests([ + { + name: "BLAKE3: 8 - Hello world", + input: "Hello world", + expectedOutput: "e7e6fb7d2869d109", + recipeConfig: [ + { "op": "BLAKE3", + "args": [8, ""] } + ] + }, + { + name: "BLAKE3: 16 - Hello world 2", + input: "Hello world 2", + expectedOutput: "2a3df5fe5f0d3fcdd995fc203c7f7c52", + recipeConfig: [ + { "op": "BLAKE3", + "args": [16, ""] } + ] + }, + { + name: "BLAKE3: 32 - Hello world", + input: "Hello world", + expectedOutput: "e7e6fb7d2869d109b62cdb1227208d4016cdaa0af6603d95223c6a698137d945", + recipeConfig: [ + { "op": "BLAKE3", + "args": [32, ""] } + ] + }, + { + name: "BLAKE3: Key Test", + input: "Hello world", + expectedOutput: "59dd23ac9d025690", + recipeConfig: [ + { "op": "BLAKE3", + "args": [8, "ThiskeyisexactlythirtytwoBytesLo"] } + ] + }, + { + name: "BLAKE3: Key Test 2", + input: "Hello world", + expectedOutput: "c8302c9634c1da42", + recipeConfig: [ + { "op": "BLAKE3", + "args": [8, "ThiskeyisexactlythirtytwoByteslo"] } + ] + } +]); diff --git a/tests/operations/tests/Base32.mjs b/tests/operations/tests/Base32.mjs new file mode 100644 index 00000000..760cdf14 --- /dev/null +++ b/tests/operations/tests/Base32.mjs @@ -0,0 +1,176 @@ +/** + * Base32 Tests + * + * @author Peter C-S [petercs@purelymail.com] + * @license Apache-2.0 + */ + +import TestRegister from "../../lib/TestRegister.mjs"; +import {ALPHABET_OPTIONS} from "../../../src/core/lib/Base32.mjs"; + +// Example Standard Base32 Tests +const STANDARD_INP = "HELLO BASE32"; +const STANDARD_OUT = "JBCUYTCPEBBECU2FGMZA===="; + +// Example Hex Extended Base32 Tests +const EXTENDED_INP = "HELLO BASE32 EXTENDED"; +const EXTENDED_OUT = "912KOJ2F41142KQ56CP20HAOAH2KSH258G======"; + +// All Bytes +const ALL_BYTES = [ + "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", + "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", + "\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f", + "\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f", + "\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f", + "\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f", + "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f", + "\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f", + "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f", + "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f", + "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf", + "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf", + "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf", + "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf", + "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef", + "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff", +].join(""); + +const ALL_BYTES_EXTENDED_OUT = "000G40O40K30E209185GO38E1S8124GJ2GAHC5OO34D1M70T3OFI08924CI2A9H750KIKAPC5KN2UC1H68PJ8D9M6SS3IEHR7GUJSFQ085146H258P3KGIAA9D64QJIFA18L4KQKALB5EM2PB9DLONAUBTG62OJ3CHIMCPR8D5L6MR3DDPNN0SBIEDQ7ATJNF1SNKURSFLV7V041GA1O91C6GU48J2KBHI6OT3SGI699754LIQBPH6CQJEE9R7KVK2GQ58T4KMJAFA59LALQPBDELUOB3CLJMIQRDDTON6TBNF5TNQVS1GE2OF2CBHM7P34SLIUCPN7CVK6HQB9T9LEMQVCDJMMRRJETTNV0S7HE7P75SRJUHQFATFMERRNFU3OV5SVKUNRFFU7PVBTVPVFUVS======"; +const ALL_BYTES_STANDARD_OUT = "AAAQEAYEAUDAOCAJBIFQYDIOB4IBCEQTCQKRMFYYDENBWHA5DYPSAIJCEMSCKJRHFAUSUKZMFUXC6MBRGIZTINJWG44DSOR3HQ6T4P2AIFBEGRCFIZDUQSKKJNGE2TSPKBIVEU2UKVLFOWCZLJNVYXK6L5QGCYTDMRSWMZ3INFVGW3DNNZXXA4LSON2HK5TXPB4XU634PV7H7AEBQKBYJBMGQ6EITCULRSGY5D4QSGJJHFEVS2LZRGM2TOOJ3HU7UCQ2FI5EUWTKPKFJVKV2ZLNOV6YLDMVTWS23NN5YXG5LXPF5X274BQOCYPCMLRWHZDE4VS6MZXHM7UGR2LJ5JVOW27MNTWW33TO55X7A4HROHZHF43T6R2PK5PWO33XP6DY7F47U6X3PP6HZ7L57Z7P674======"; + +TestRegister.addTests([ + { + name: "To Base32 Standard: nothing", + input: "", + expectedOutput: "", + recipeConfig: [ + { + op: "To Base32", + args: [ALPHABET_OPTIONS[0].value], + }, + ], + }, + { + name: "To Base32 Hex Extended: nothing", + input: "", + expectedOutput: "", + recipeConfig: [ + { + op: "To Base32", + args: [ALPHABET_OPTIONS[1].value], + }, + ], + }, + { + name: "From Base32 Standard: nothing", + input: "", + expectedOutput: "", + recipeConfig: [ + { + op: "From Base32", + args: [ALPHABET_OPTIONS[0].value, false], + }, + ], + }, + { + name: "From Base32 Hex Extended: nothing", + input: "", + expectedOutput: "", + recipeConfig: [ + { + op: "From Base32", + args: [ALPHABET_OPTIONS[1].value, false], + }, + ], + }, + { + name: "To Base32 Standard: " + STANDARD_INP, + input: STANDARD_INP, + expectedOutput: STANDARD_OUT, + recipeConfig: [ + { + op: "To Base32", + args: [ALPHABET_OPTIONS[0].value], + }, + ], + }, + { + name: "To Base32 Hex Extended: " + EXTENDED_INP, + input: EXTENDED_INP, + expectedOutput: EXTENDED_OUT, + recipeConfig: [ + { + op: "To Base32", + args: [ALPHABET_OPTIONS[1].value], + }, + ], + }, + { + name: "From Base32 Standard: " + STANDARD_OUT, + input: STANDARD_OUT, + expectedOutput: STANDARD_INP, + recipeConfig: [ + { + op: "From Base32", + args: [ALPHABET_OPTIONS[0].value, false], + }, + ], + }, + { + name: "From Base32 Hex Extended: " + EXTENDED_OUT, + input: EXTENDED_OUT, + expectedOutput: EXTENDED_INP, + recipeConfig: [ + { + op: "From Base32", + args: [ALPHABET_OPTIONS[1].value, false], + }, + ], + }, + { + name: "To Base32 Hex Standard: All Bytes", + input: ALL_BYTES, + expectedOutput: ALL_BYTES_STANDARD_OUT, + recipeConfig: [ + { + op: "To Base32", + args: [ALPHABET_OPTIONS[0].value], + }, + ], + }, + { + name: "To Base32 Hex Extended: All Bytes", + input: ALL_BYTES, + expectedOutput: ALL_BYTES_EXTENDED_OUT, + recipeConfig: [ + { + op: "To Base32", + args: [ALPHABET_OPTIONS[1].value], + }, + ], + }, + { + name: "From Base32 Hex Standard: All Bytes", + input: ALL_BYTES_STANDARD_OUT, + expectedOutput: ALL_BYTES, + recipeConfig: [ + { + op: "From Base32", + args: [ALPHABET_OPTIONS[0].value, false], + }, + ], + }, + { + name: "From Base32 Hex Extended: All Bytes", + input: ALL_BYTES_EXTENDED_OUT, + expectedOutput: ALL_BYTES, + recipeConfig: [ + { + op: "From Base32", + args: [ALPHABET_OPTIONS[1].value, false], + }, + ], + }, +]); + diff --git a/tests/operations/tests/Base58.mjs b/tests/operations/tests/Base58.mjs index c23ba9ab..8090b84b 100644 --- a/tests/operations/tests/Base58.mjs +++ b/tests/operations/tests/Base58.mjs @@ -53,6 +53,28 @@ TestRegister.addTests([ }, ], }, + { + name: "To Base58 all null", + input: "\0\0\0\0\0\0", + expectedOutput: "111111", + recipeConfig: [ + { + op: "To Base58", + args: ["123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"], + }, + ], + }, + { + name: "From Base58 all null", + input: "111111", + expectedOutput: "\0\0\0\0\0\0", + recipeConfig: [ + { + op: "From Base58", + args: ["123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"], + }, + ], + }, { name: "To Base58 with null prefix and suffix", input: "\0\0\0Hello\0\0\0", diff --git a/tests/operations/tests/Base85.mjs b/tests/operations/tests/Base85.mjs index 8e1d0a23..44e12ee2 100644 --- a/tests/operations/tests/Base85.mjs +++ b/tests/operations/tests/Base85.mjs @@ -16,6 +16,10 @@ DIb:@FD,*)+C]U=@3BN#EcYf8ATD3s@q?d$AftVqCh[NqF-FD5W8ARlolDIal(\
DIdu\
D.RTpAKYo'+CT/5+Cei#DII?(E,9)oF*2M7/c";
+const allZeroExample = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff";
+
+const allZeroOutput = "zz!!*-'\"9eu7#RLhG$k3[W&.oNg'GVB\"(`=52*$$(B+<_pR,UFcb-n-Vr/1iJ-0JP==1c70M3&s#]4?Ykm5X@_(6q'R884cEH9MJ8X:f1+h<)lt#=BSg3>[:ZC?t!MSA7]@cBPD3sCi+'.E,fo>FEMbNG^4U^I!pHnJ:W<)KS>/9Ll%\"IN/`jYOHG]iPa.Q$R$jD4S=Q7DTV8*TUnsrdW2ZetXKAY/Yd(L?['d?O\\@K2_]Y2%o^qmn*`5Ta:aN;TJbg\"GZd*^:jeCE.%f\\,!5gtgiEi8N\\UjQ5OekiqBum-X60nF?)@o_%qPq\"ad`r;HWp";
+
TestRegister.addTests([
{
name: "To Base85",
@@ -45,4 +49,22 @@ TestRegister.addTests([
"args": ["!-u", false] }
]
},
+ {
+ name: "To Base85",
+ input: allZeroExample,
+ expectedOutput: allZeroOutput,
+ recipeConfig: [
+ { "op": "To Base85",
+ "args": ["!-u"] }
+ ]
+ },
+ {
+ name: "From Base85",
+ input: allZeroOutput,
+ expectedOutput: allZeroExample,
+ recipeConfig: [
+ { "op": "From Base85",
+ "args": ["!-u", true, "z"] }
+ ]
+ },
]);
diff --git a/tests/operations/tests/Base92.mjs b/tests/operations/tests/Base92.mjs
new file mode 100644
index 00000000..2811182d
--- /dev/null
+++ b/tests/operations/tests/Base92.mjs
@@ -0,0 +1,89 @@
+/**
+ * Base92 tests.
+ *
+ * @author sg5506844 [sg5506844@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+ {
+ name: "To Base92: nothing",
+ input: "",
+ expectedOutput: "",
+ recipeConfig: [
+ {
+ op: "To Base92",
+ args: [],
+ },
+ ],
+ },
+ {
+ name: "To Base92: Spec encoding example 1",
+ input: "AB",
+ expectedOutput: "8y2",
+ recipeConfig: [
+ {
+ op: "To Base92",
+ args: [],
+ },
+ ],
+ },
+ {
+ name: "To Base92: Spec encoding example 2",
+ input: "Hello!!",
+ expectedOutput: ";K_$aOTo&",
+ recipeConfig: [
+ {
+ op: "To Base92",
+ args: [],
+ },
+ ],
+ },
+ {
+ name: "To Base92: Spec encoding example 3",
+ input: "base-92",
+ expectedOutput: "DX2?V?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~^?M-^@M-^AM-^BM-^CM-^DM-^EM-^FM-^GM-^HM-^IM-^JM-^KM-^LM-^MM-^NM-^OM-^PM-^QM-^RM-^SM-^TM-^UM-^VM-^WM-^XM-^YM-^ZM-^[M-^\\M-^]M-^^M-^_M- M-!M-\"M-#M-$M-%M-&M-'M-(M-)M-*M-+M-,M--M-.M-/M-0M-1M-2M-3M-4M-5M-6M-7M-8M-9M-:M-;M-M-?M-@M-AM-BM-CM-DM-EM-FM-GM-HM-IM-JM-KM-LM-MM-NM-OM-PM-QM-RM-SM-TM-UM-VM-WM-XM-YM-ZM-[M-\\M-]M-^M-_M-`M-aM-bM-cM-dM-eM-fM-gM-hM-iM-jM-kM-lM-mM-nM-oM-pM-qM-rM-sM-tM-uM-vM-wM-xM-yM-zM-{M-|M-}M-~M-^?",
+ expectedOutput: "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x1f\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\x8d\x2d\x5f\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
+ recipeConfig: [
+ {
+ op: "Caret/M-decode",
+ args: [],
+ },
+ ],
+ },
+]);
+
diff --git a/tests/operations/tests/ChaCha.mjs b/tests/operations/tests/ChaCha.mjs
new file mode 100644
index 00000000..d194390d
--- /dev/null
+++ b/tests/operations/tests/ChaCha.mjs
@@ -0,0 +1,170 @@
+/**
+ * ChaCha tests.
+ *
+ * @author joostrijneveld [joost@joostrijneveld.nl]
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+ {
+ name: "ChaCha: no key",
+ input: "",
+ expectedOutput: `Invalid key length: 0 bytes.
+
+ChaCha uses a key of 16 or 32 bytes (128 or 256 bits).`,
+ recipeConfig: [
+ {
+ "op": "ChaCha",
+ "args": [
+ {"option": "Hex", "string": ""},
+ {"option": "Hex", "string": ""},
+ 0, "20", "Hex", "Hex",
+ ]
+ }
+ ],
+ },
+ {
+ name: "ChaCha: no nonce",
+ input: "",
+ expectedOutput: `Invalid nonce length: 0 bytes.
+
+ChaCha uses a nonce of 8 or 12 bytes (64 or 96 bits).`,
+ recipeConfig: [
+ {
+ "op": "ChaCha",
+ "args": [
+ {"option": "Hex", "string": "00000000000000000000000000000000"},
+ {"option": "Hex", "string": ""},
+ 0, "20", "Hex", "Hex",
+ ]
+ }
+ ],
+ },
+ {
+ name: "ChaCha: RFC8439",
+ input: "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.",
+ expectedOutput: "6e 2e 35 9a 25 68 f9 80 41 ba 07 28 dd 0d 69 81 e9 7e 7a ec 1d 43 60 c2 0a 27 af cc fd 9f ae 0b f9 1b 65 c5 52 47 33 ab 8f 59 3d ab cd 62 b3 57 16 39 d6 24 e6 51 52 ab 8f 53 0c 35 9f 08 61 d8 07 ca 0d bf 50 0d 6a 61 56 a3 8e 08 8a 22 b6 5e 52 bc 51 4d 16 cc f8 06 81 8c e9 1a b7 79 37 36 5a f9 0b bf 74 a3 5b e6 b4 0b 8e ed f2 78 5e 42 87 4d",
+ recipeConfig: [
+ {
+ "op": "ChaCha",
+ "args": [
+ {"option": "Hex", "string": "00:01:02:03:04:05:06:07:08:09:0a:0b:0c:0d:0e:0f:10:11:12:13:14:15:16:17:18:19:1a:1b:1c:1d:1e:1f"},
+ {"option": "Hex", "string": "00:00:00:00:00:00:00:4a:00:00:00:00"},
+ 1, "20", "Raw", "Hex",
+ ]
+ }
+ ],
+ },
+ {
+ name: "ChaCha: RFC8439 Raw output",
+ input: "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.",
+ expectedOutput: "6e 2e 35 9a 25 68 f9 80 41 ba 07 28 dd 0d 69 81 e9 7e 7a ec 1d 43 60 c2 0a 27 af cc fd 9f ae 0b f9 1b 65 c5 52 47 33 ab 8f 59 3d ab cd 62 b3 57 16 39 d6 24 e6 51 52 ab 8f 53 0c 35 9f 08 61 d8 07 ca 0d bf 50 0d 6a 61 56 a3 8e 08 8a 22 b6 5e 52 bc 51 4d 16 cc f8 06 81 8c e9 1a b7 79 37 36 5a f9 0b bf 74 a3 5b e6 b4 0b 8e ed f2 78 5e 42 87 4d",
+ recipeConfig: [
+ {
+ "op": "ChaCha",
+ "args": [
+ {"option": "Hex", "string": "00:01:02:03:04:05:06:07:08:09:0a:0b:0c:0d:0e:0f:10:11:12:13:14:15:16:17:18:19:1a:1b:1c:1d:1e:1f"},
+ {"option": "Hex", "string": "00:00:00:00:00:00:00:4a:00:00:00:00"},
+ 1, "20", "Raw", "Raw",
+ ]
+ },
+ {
+ "op": "To Hex",
+ "args": []
+ },
+ ],
+ },
+ {
+ name: "ChaCha: draft-strombergson-chacha-test-vectors-01 TC7.1",
+ input: "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+ expectedOutput: "29 56 0d 28 0b 45 28 40 0a 8f 4b 79 53 69 fb 3a 01 10 55 99 e9 f1 ed 58 27 9c fc 9e ce 2d c5 f9 9f 1c 2e 52 c9 82 38 f5 42 a5 c0 a8 81 d8 50 b6 15 d3 ac d9 fb db 02 6e 93 68 56 5d a5 0e 0d 49 dd 5b e8 ef 74 24 8b 3e 25 1d 96 5d 8f cb 21 e7 cf e2 04 d4 00 78 06 fb ee 3c e9 4c 74 bf ba d2 c1 1c 62 1b a0 48 14 7c 5c aa 94 d1 82 cc ff 6f d5 cf 44 ad f9 6e 3d 68 28 1b b4 96 76 af 87 e7",
+ recipeConfig: [
+ {
+ "op": "ChaCha",
+ "args": [
+ {"option": "Hex", "string": "00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff"},
+ {"option": "Hex", "string": "0f 1e 2d 3c 4b 5a 69 78"},
+ 0, "8", "Hex", "Hex",
+ ]
+ }
+ ],
+ },
+ {
+ name: "ChaCha: draft-strombergson-chacha-test-vectors-01 TC7.2",
+ input: "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+ expectedOutput: "5e dd c2 d9 42 8f ce ee c5 0a 52 a9 64 ea e0 ff b0 4b 2d e0 06 a9 b0 4c ff 36 8f fa 92 11 16 b2 e8 e2 64 ba bd 2e fa 0d e4 3e f2 e3 b6 d0 65 e8 f7 c0 a1 78 37 b0 a4 0e b0 e2 c7 a3 74 2c 87 53 ed e5 f3 f6 d1 9b e5 54 67 5e 50 6a 77 5c 63 f0 94 d4 96 5c 31 93 19 dc d7 50 6f 45 7b 11 7b 84 b1 0b 24 6e 95 6c 2d a8 89 8a 65 6c ee f3 f7 b7 16 45 b1 9f 70 1d b8 44 85 ce 51 21 f0 f6 17 ef",
+ recipeConfig: [
+ {
+ "op": "ChaCha",
+ "args": [
+ {"option": "Hex", "string": "00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff"},
+ {"option": "Hex", "string": "0f 1e 2d 3c 4b 5a 69 78"},
+ 0, "12", "Hex", "Hex",
+ ]
+ }
+ ],
+ },
+ {
+ name: "ChaCha: draft-strombergson-chacha-test-vectors-01 TC7.3",
+ input: "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+ expectedOutput: "d1 ab f6 30 46 7e b4 f6 7f 1c fb 47 cd 62 6a ae 8a fe db be 4f f8 fc 5f e9 cf ae 30 7e 74 ed 45 1f 14 04 42 5a d2 b5 45 69 d5 f1 81 48 93 99 71 ab b8 fa fc 88 ce 4a c7 fe 1c 3d 1f 7a 1e b7 ca e7 6c a8 7b 61 a9 71 35 41 49 77 60 dd 9a e0 59 35 0c ad 0d ce df aa 80 a8 83 11 9a 1a 6f 98 7f d1 ce 91 fd 8e e0 82 80 34 b4 11 20 0a 97 45 a2 85 55 44 75 d1 2a fc 04 88 7f ef 35 16 d1 2a 2c",
+ recipeConfig: [
+ {
+ "op": "ChaCha",
+ "args": [
+ {"option": "Hex", "string": "00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff"},
+ {"option": "Hex", "string": "0f 1e 2d 3c 4b 5a 69 78"},
+ 0, "20", "Hex", "Hex",
+ ]
+ }
+ ],
+ },
+ {
+ name: "ChaCha: draft-strombergson-chacha-test-vectors-01 TC7.4",
+ input: "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+ expectedOutput: "db 43 ad 9d 1e 84 2d 12 72 e4 53 0e 27 6b 3f 56 8f 88 59 b3 f7 cf 6d 9d 2c 74 fa 53 80 8c b5 15 7a 8e bf 46 ad 3d cc 4b 6c 7d ad de 13 17 84 b0 12 0e 0e 22 f6 d5 f9 ff a7 40 7d 4a 21 b6 95 d9 c5 dd 30 bf 55 61 2f ab 9b dd 11 89 20 c1 98 16 47 0c 7f 5d cd 42 32 5d bb ed 8c 57 a5 62 81 c1 44 cb 0f 03 e8 1b 30 04 62 4e 06 50 a1 ce 5a fa f9 a7 cd 81 63 f6 db d7 26 02 25 7d d9 6e 47 1e",
+ recipeConfig: [
+ {
+ "op": "ChaCha",
+ "args": [
+ {"option": "Hex", "string": "00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff ff ee dd cc bb aa 99 88 77 66 55 44 33 22 11 00"},
+ {"option": "Hex", "string": "0f 1e 2d 3c 4b 5a 69 78"},
+ 0, "8", "Hex", "Hex",
+ ]
+ }
+ ],
+ },
+ {
+ name: "ChaCha: draft-strombergson-chacha-test-vectors-01 TC7.5",
+ input: "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+ expectedOutput: "7e d1 2a 3a 63 91 2a e9 41 ba 6d 4c 0d 5e 86 2e 56 8b 0e 55 89 34 69 35 50 5f 06 4b 8c 26 98 db f7 d8 50 66 7d 8e 67 be 63 9f 3b 4f 6a 16 f9 2e 65 ea 80 f6 c7 42 94 45 da 1f c2 c1 b9 36 50 40 e3 2e 50 c4 10 6f 3b 3d a1 ce 7c cb 1e 71 40 b1 53 49 3c 0f 3a d9 a9 bc ff 07 7e c4 59 6f 1d 0f 29 bf 9c ba a5 02 82 0f 73 2a f5 a9 3c 49 ee e3 3d 1c 4f 12 af 3b 42 97 af 91 fe 41 ea 9e 94 a2",
+ recipeConfig: [
+ {
+ "op": "ChaCha",
+ "args": [
+ {"option": "Hex", "string": "00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff ff ee dd cc bb aa 99 88 77 66 55 44 33 22 11 00"},
+ {"option": "Hex", "string": "0f 1e 2d 3c 4b 5a 69 78"},
+ 0, "12", "Hex", "Hex",
+ ]
+ }
+ ],
+ },
+ {
+ name: "ChaCha: draft-strombergson-chacha-test-vectors-01 TC7.6",
+ input: "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
+ expectedOutput: "9f ad f4 09 c0 08 11 d0 04 31 d6 7e fb d8 8f ba 59 21 8d 5d 67 08 b1 d6 85 86 3f ab bb 0e 96 1e ea 48 0f d6 fb 53 2b fd 49 4b 21 51 01 50 57 42 3a b6 0a 63 fe 4f 55 f7 a2 12 e2 16 7c ca b9 31 fb fd 29 cf 7b c1 d2 79 ed df 25 dd 31 6b b8 84 3d 6e de e0 bd 1e f1 21 d1 2f a1 7c bc 2c 57 4c cc ab 5e 27 51 67 b0 8b d6 86 f8 a0 9d f8 7e c3 ff b3 53 61 b9 4e bf a1 3f ec 0e 48 89 d1 8d a5",
+ recipeConfig: [
+ {
+ "op": "ChaCha",
+ "args": [
+ {"option": "Hex", "string": "00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff ff ee dd cc bb aa 99 88 77 66 55 44 33 22 11 00"},
+ {"option": "Hex", "string": "0f 1e 2d 3c 4b 5a 69 78"},
+ 0, "20", "Hex", "Hex",
+ ]
+ }
+ ],
+ },
+]);
diff --git a/tests/operations/tests/Checksum.mjs b/tests/operations/tests/Checksum.mjs
deleted file mode 100644
index 142ee267..00000000
--- a/tests/operations/tests/Checksum.mjs
+++ /dev/null
@@ -1,241 +0,0 @@
-/**
- * Checksum tests.
- *
- * @author n1474335 [n1474335@gmail.com]
- * @copyright Crown Copyright 2018
- * @license Apache-2.0
- */
-import TestRegister from "../../lib/TestRegister.mjs";
-
-const BASIC_STRING = "The ships hung in the sky in much the same way that bricks don't.";
-const UTF8_STR = "ნუ პანიკას";
-const ALL_BYTES = [
- "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
- "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f",
- "\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f",
- "\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f",
- "\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f",
- "\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f",
- "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f",
- "\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f",
- "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f",
- "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f",
- "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf",
- "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf",
- "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf",
- "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf",
- "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef",
- "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff",
-].join("");
-
-TestRegister.addTests([
- {
- name: "CRC-8: nothing",
- input: "",
- expectedOutput: "00",
- recipeConfig: [
- {
- "op": "CRC-8 Checksum",
- "args": ["CRC-8"]
- }
- ]
- },
- {
- name: "CRC-8: default check",
- input: "123456789",
- expectedOutput: "f4",
- recipeConfig: [
- {
- "op": "CRC-8 Checksum",
- "args": ["CRC-8"]
- }
- ]
- },
- {
- name: "CRC-8: CDMA2000",
- input: "123456789",
- expectedOutput: "da",
- recipeConfig: [
- {
- "op": "CRC-8 Checksum",
- "args": ["CRC-8/CDMA2000"]
- }
- ]
- },
- {
- name: "CRC-8: DARC",
- input: "123456789",
- expectedOutput: "15",
- recipeConfig: [
- {
- "op": "CRC-8 Checksum",
- "args": ["CRC-8/DARC"]
- }
- ]
- },
- {
- name: "CRC-8: DVB-S2",
- input: "123456789",
- expectedOutput: "bc",
- recipeConfig: [
- {
- "op": "CRC-8 Checksum",
- "args": ["CRC-8/DVB-S2"]
- }
- ]
- },
- {
- name: "CRC-8: EBU",
- input: "123456789",
- expectedOutput: "97",
- recipeConfig: [
- {
- "op": "CRC-8 Checksum",
- "args": ["CRC-8/EBU"]
- }
- ]
- },
- {
- name: "CRC-8: I-CODE",
- input: "123456789",
- expectedOutput: "7e",
- recipeConfig: [
- {
- "op": "CRC-8 Checksum",
- "args": ["CRC-8/I-CODE"]
- }
- ]
- },
- {
- name: "CRC-8: ITU",
- input: "123456789",
- expectedOutput: "a1",
- recipeConfig: [
- {
- "op": "CRC-8 Checksum",
- "args": ["CRC-8/ITU"]
- }
- ]
- },
- {
- name: "CRC-8: MAXIM",
- input: "123456789",
- expectedOutput: "a1",
- recipeConfig: [
- {
- "op": "CRC-8 Checksum",
- "args": ["CRC-8/MAXIM"]
- }
- ]
- },
- {
- name: "CRC-8: ROHC",
- input: "123456789",
- expectedOutput: "d0",
- recipeConfig: [
- {
- "op": "CRC-8 Checksum",
- "args": ["CRC-8/ROHC"]
- }
- ]
- },
- {
- name: "CRC-8: WCDMA",
- input: "123456789",
- expectedOutput: "25",
- recipeConfig: [
- {
- "op": "CRC-8 Checksum",
- "args": ["CRC-8/WCDMA"]
- }
- ]
- },
- {
- name: "CRC-16: nothing",
- input: "",
- expectedOutput: "0000",
- recipeConfig: [
- {
- "op": "CRC-16 Checksum",
- "args": []
- }
- ]
- },
- {
- name: "CRC-16: basic string",
- input: BASIC_STRING,
- expectedOutput: "0c70",
- recipeConfig: [
- {
- "op": "CRC-16 Checksum",
- "args": []
- }
- ]
- },
- {
- name: "CRC-16: UTF-8",
- input: UTF8_STR,
- expectedOutput: "dcf6",
- recipeConfig: [
- {
- "op": "CRC-16 Checksum",
- "args": []
- }
- ]
- },
- {
- name: "CRC-16: all bytes",
- input: ALL_BYTES,
- expectedOutput: "bad3",
- recipeConfig: [
- {
- "op": "CRC-16 Checksum",
- "args": []
- }
- ]
- },
- {
- name: "CRC-32: nothing",
- input: "",
- expectedOutput: "00000000",
- recipeConfig: [
- {
- "op": "CRC-32 Checksum",
- "args": []
- }
- ]
- },
- {
- name: "CRC-32: basic string",
- input: BASIC_STRING,
- expectedOutput: "bf4b739c",
- recipeConfig: [
- {
- "op": "CRC-32 Checksum",
- "args": []
- }
- ]
- },
- {
- name: "CRC-32: UTF-8",
- input: UTF8_STR,
- expectedOutput: "87553290",
- recipeConfig: [
- {
- "op": "CRC-32 Checksum",
- "args": []
- }
- ]
- },
- {
- name: "CRC-32: all bytes",
- input: ALL_BYTES,
- expectedOutput: "29058c73",
- recipeConfig: [
- {
- "op": "CRC-32 Checksum",
- "args": []
- }
- ]
- }
-]);
diff --git a/tests/operations/tests/CipherSaber2.mjs b/tests/operations/tests/CipherSaber2.mjs
index dd675d45..9872c7ef 100644
--- a/tests/operations/tests/CipherSaber2.mjs
+++ b/tests/operations/tests/CipherSaber2.mjs
@@ -21,13 +21,16 @@ TestRegister.addTests([
],
},
{
+ // input taken from https://ciphersaber.gurus.org/
name: "CipherSaber2 Decrypt",
- input: "\x5d\xd9\x7f\xeb\x77\x3c\x42\x9d\xfe\x9c\x3b\x21\x63\xbd\x53\x38\x18\x7c\x36\x37",
- expectedOutput: "helloworld",
+ input: "\x6f\x6d\x0b\xab\xf3\xaa\x67\x19\x03\x15\x30\xed\xb6\x77" +
+ "\xca\x74\xe0\x08\x9d\xd0\xe7\xb8\x85\x43\x56\xbb\x14\x48\xe3" +
+ "\x7c\xdb\xef\xe7\xf3\xa8\x4f\x4f\x5f\xb3\xfd",
+ expectedOutput: "This is a test of CipherSaber.",
recipeConfig: [
{
op: "CipherSaber2 Decrypt",
- args: [{ "option": "Latin1", "string": "test" }, 20],
+ args: [{ "option": "Latin1", "string": "asdfg" }, 1],
},
],
},
diff --git a/tests/operations/tests/Ciphers.mjs b/tests/operations/tests/Ciphers.mjs
index 47453cf7..16aba950 100644
--- a/tests/operations/tests/Ciphers.mjs
+++ b/tests/operations/tests/Ciphers.mjs
@@ -528,4 +528,15 @@ TestRegister.addTests([
}
],
},
+ {
+ name: "Rail Fence Cipher Encode: Normal with Offset with Spaces",
+ input: "No one expects the spanish Inquisition.",
+ expectedOutput: " e n ut.ooeepcstesaihIqiiinNnxthpsnso",
+ recipeConfig: [
+ {
+ "op": "Rail Fence Cipher Encode",
+ "args": [3, 2]
+ }
+ ],
+ },
]);
diff --git a/tests/operations/tests/Code.mjs b/tests/operations/tests/Code.mjs
index 6ff1d97c..0a25c0e8 100644
--- a/tests/operations/tests/Code.mjs
+++ b/tests/operations/tests/Code.mjs
@@ -189,7 +189,7 @@ TestRegister.addTests([
recipeConfig: [
{
"op": "JPath expression",
- "args": ["", "\n", true]
+ "args": ["", "\n"]
}
],
},
@@ -205,7 +205,7 @@ TestRegister.addTests([
recipeConfig: [
{
"op": "JPath expression",
- "args": ["$.store.book[*].author", "\n", true]
+ "args": ["$.store.book[*].author", "\n"]
}
],
},
@@ -223,7 +223,7 @@ TestRegister.addTests([
recipeConfig: [
{
"op": "JPath expression",
- "args": ["$..title", "\n", true]
+ "args": ["$..title", "\n"]
}
],
},
@@ -238,7 +238,7 @@ TestRegister.addTests([
recipeConfig: [
{
"op": "JPath expression",
- "args": ["$.store.*", "\n", true]
+ "args": ["$.store.*", "\n"]
}
],
},
@@ -249,7 +249,7 @@ TestRegister.addTests([
recipeConfig: [
{
"op": "JPath expression",
- "args": ["$..book[-1:]", "\n", true]
+ "args": ["$..book[-1:]", "\n"]
}
],
},
@@ -263,7 +263,7 @@ TestRegister.addTests([
recipeConfig: [
{
"op": "JPath expression",
- "args": ["$..book[:2]", "\n", true]
+ "args": ["$..book[:2]", "\n"]
}
],
},
@@ -277,7 +277,7 @@ TestRegister.addTests([
recipeConfig: [
{
"op": "JPath expression",
- "args": ["$..book[?(@.isbn)]", "\n", false]
+ "args": ["$..book[?(@.isbn)]", "\n"]
}
],
},
@@ -292,7 +292,7 @@ TestRegister.addTests([
recipeConfig: [
{
"op": "JPath expression",
- "args": ["$..book[?(@.price<30 && @.category==\"fiction\")]", "\n", false]
+ "args": ["$..book[?(@.price<30 && @.category==\"fiction\")]", "\n"]
}
],
},
@@ -306,7 +306,7 @@ TestRegister.addTests([
recipeConfig: [
{
"op": "JPath expression",
- "args": ["$..book[?(@.price<10)]", "\n", false]
+ "args": ["$..book[?(@.price<10)]", "\n"]
}
],
},
@@ -318,13 +318,25 @@ TestRegister.addTests([
"op": "JPath expression",
"args": [
"$..[?(({__proto__:[].constructor}).constructor(\"self.postMessage({action:'bakeComplete',data:{bakeId:1,dish:{type:1,value:''},duration:1,error:false,id:undefined,inputNum:2,progress:1,result:'
")} @@ -584,42 +627,6 @@ class RecipeWaiter { adjustWidth() { const recList = document.getElementById("rec-list"); - if (!this.ingredientRuleID) { - this.ingredientRuleID = null; - this.ingredientChildRuleID = null; - - // Find relevant rules in the stylesheet - // try/catch for chrome 64+ CORS error on cssRules. - try { - for (const i in document.styleSheets[0].cssRules) { - if (document.styleSheets[0].cssRules[i].selectorText === ".ingredients") { - this.ingredientRuleID = i; - } - if (document.styleSheets[0].cssRules[i].selectorText === ".ingredients > div") { - this.ingredientChildRuleID = i; - } - } - } catch (e) { - // Do nothing. - } - } - - if (!this.ingredientRuleID || !this.ingredientChildRuleID) return; - - const ingredientRule = document.styleSheets[0].cssRules[this.ingredientRuleID]; - const ingredientChildRule = document.styleSheets[0].cssRules[this.ingredientChildRuleID]; - - if (recList.clientWidth < 450) { - ingredientRule.style.gridTemplateColumns = "auto auto"; - ingredientChildRule.style.gridColumn = "1 / span 2"; - } else if (recList.clientWidth < 620) { - ingredientRule.style.gridTemplateColumns = "auto auto auto"; - ingredientChildRule.style.gridColumn = "1 / span 3"; - } else { - ingredientRule.style.gridTemplateColumns = "auto auto auto auto"; - ingredientChildRule.style.gridColumn = "1 / span 4"; - } - // Hide Chef icon on Bake button if the page is compressed const bakeIcon = document.querySelector("#bake img"); @@ -635,7 +642,7 @@ class RecipeWaiter { const controlsContent = document.getElementById("controls-content"); const scale = (controls.clientWidth - 1) / controlsContent.scrollWidth; - controlsContent.style.transform = `translate(-50%, -50%) scale(${scale})`; + controlsContent.style.transform = `scale(${scale})`; } } diff --git a/src/web/waiters/SeasonalWaiter.mjs b/src/web/waiters/SeasonalWaiter.mjs index 8ad93452..c754dc8f 100755 --- a/src/web/waiters/SeasonalWaiter.mjs +++ b/src/web/waiters/SeasonalWaiter.mjs @@ -30,8 +30,7 @@ class SeasonalWaiter { window.addEventListener("keydown", this.konamiCodeListener.bind(this)); // CyberChef Challenge - // eslint-disable-next-line no-console - console.log("43 6f 6e 67 72 61 74 75 6c 61 74 69 6f 6e 73 2c 20 79 6f 75 20 68 61 76 65 20 63 6f 6d 70 6c 65 74 65 64 20 43 79 62 65 72 43 68 65 66 20 63 68 61 6c 6c 65 6e 67 65 20 23 31 21 0a 0a 54 68 69 73 20 63 68 61 6c 6c 65 6e 67 65 20 65 78 70 6c 6f 72 65 64 20 68 65 78 61 64 65 63 69 6d 61 6c 20 65 6e 63 6f 64 69 6e 67 2e 20 54 6f 20 6c 65 61 72 6e 20 6d 6f 72 65 2c 20 76 69 73 69 74 20 77 69 6b 69 70 65 64 69 61 2e 6f 72 67 2f 77 69 6b 69 2f 48 65 78 61 64 65 63 69 6d 61 6c 2e 0a 0a 54 68 65 20 63 6f 64 65 20 66 6f 72 20 74 68 69 73 20 63 68 61 6c 6c 65 6e 67 65 20 69 73 20 39 64 34 63 62 63 65 66 2d 62 65 35 32 2d 34 37 35 31 2d 61 32 62 32 2d 38 33 33 38 65 36 34 30 39 34 31 36 20 28 6b 65 65 70 20 74 68 69 73 20 70 72 69 76 61 74 65 29 2e 0a 0a 54 68 65 20 6e 65 78 74 20 63 68 61 6c 6c 65 6e 67 65 20 63 61 6e 20 62 65 20 66 6f 75 6e 64 20 61 74 20 68 74 74 70 73 3a 2f 2f 70 61 73 74 65 62 69 6e 2e 63 6f 6d 2f 47 53 6e 54 41 6d 6b 56 2e"); + log.info("43 6f 6e 67 72 61 74 75 6c 61 74 69 6f 6e 73 2c 20 79 6f 75 20 68 61 76 65 20 63 6f 6d 70 6c 65 74 65 64 20 43 79 62 65 72 43 68 65 66 20 63 68 61 6c 6c 65 6e 67 65 20 23 31 21 0a 0a 54 68 69 73 20 63 68 61 6c 6c 65 6e 67 65 20 65 78 70 6c 6f 72 65 64 20 68 65 78 61 64 65 63 69 6d 61 6c 20 65 6e 63 6f 64 69 6e 67 2e 20 54 6f 20 6c 65 61 72 6e 20 6d 6f 72 65 2c 20 76 69 73 69 74 20 77 69 6b 69 70 65 64 69 61 2e 6f 72 67 2f 77 69 6b 69 2f 48 65 78 61 64 65 63 69 6d 61 6c 2e 0a 0a 54 68 65 20 63 6f 64 65 20 66 6f 72 20 74 68 69 73 20 63 68 61 6c 6c 65 6e 67 65 20 69 73 20 39 64 34 63 62 63 65 66 2d 62 65 35 32 2d 34 37 35 31 2d 61 32 62 32 2d 38 33 33 38 65 36 34 30 39 34 31 36 20 28 6b 65 65 70 20 74 68 69 73 20 70 72 69 76 61 74 65 29 2e 0a 0a 54 68 65 20 6e 65 78 74 20 63 68 61 6c 6c 65 6e 67 65 20 63 61 6e 20 62 65 20 66 6f 75 6e 64 20 61 74 20 68 74 74 70 73 3a 2f 2f 70 61 73 74 65 62 69 6e 2e 63 6f 6d 2f 47 53 6e 54 41 6d 6b 56 2e"); } diff --git a/src/web/waiters/TabWaiter.mjs b/src/web/waiters/TabWaiter.mjs index 384b1ab7..a3361837 100644 --- a/src/web/waiters/TabWaiter.mjs +++ b/src/web/waiters/TabWaiter.mjs @@ -48,24 +48,6 @@ class TabWaiter { return -1; } - /** - * Gets the currently active input tab number - * - * @returns {number} - */ - getActiveInputTab() { - return this.getActiveTab("input"); - } - - /** - * Gets the currently active output tab number - * - * @returns {number} - */ - getActiveOutputTab() { - return this.getActiveTab("output"); - } - /** * Gets the li element for the tab of a given input number * @@ -83,26 +65,6 @@ class TabWaiter { return null; } - /** - * Gets the li element for an input tab of the given input number - * - * @param {inputNum} - The inputNum of the tab we're trying to get - * @returns {Element} - */ - getInputTabItem(inputNum) { - return this.getTabItem(inputNum, "input"); - } - - /** - * Gets the li element for an output tab of the given input number - * - * @param {number} inputNum - * @returns {Element} - */ - getOutputTabItem(inputNum) { - return this.getTabItem(inputNum, "output"); - } - /** * Gets a list of tab numbers for the currently displayed tabs * @@ -120,24 +82,6 @@ class TabWaiter { return nums; } - /** - * Gets a list of tab numbers for the currently displayed input tabs - * - * @returns {number[]} - */ - getInputTabList() { - return this.getTabList("input"); - } - - /** - * Gets a list of tab numbers for the currently displayed output tabs - * - * @returns {number[]} - */ - getOutputTabList() { - return this.getTabList("output"); - } - /** * Creates a new tab element for the tab bar * @@ -154,11 +98,8 @@ class TabWaiter { const newTabContent = document.createElement("div"); newTabContent.classList.add(`${io}-tab-content`); - newTabContent.innerText = `Tab ${inputNum.toString()}`; - newTabContent.addEventListener("wheel", this.manager[io].scrollTab.bind(this.manager[io]), {passive: false}); - newTab.appendChild(newTabContent); if (io === "input") { @@ -166,52 +107,24 @@ class TabWaiter { newTabButtonIcon = document.createElement("i"); newTabButton.type = "button"; newTabButton.className = "btn btn-primary bmd-btn-icon btn-close-tab"; - newTabButtonIcon.classList.add("material-icons"); newTabButtonIcon.innerText = "clear"; - newTabButton.appendChild(newTabButtonIcon); - newTabButton.addEventListener("click", this.manager.input.removeTabClick.bind(this.manager.input)); - newTab.appendChild(newTabButton); } return newTab; } - /** - * Creates a new tab element for the input tab bar - * - * @param {number} inputNum - The inputNum of the new input tab - * @param {boolean} [active=false] - If true, sets the tab to active - * @returns {Element} - */ - createInputTabElement(inputNum, active=false) { - return this.createTabElement(inputNum, active, "input"); - } - - /** - * Creates a new tab element for the output tab bar - * - * @param {number} inputNum - The inputNum of the new output tab - * @param {boolean} [active=false] - If true, sets the tab to active - * @returns {Element} - */ - createOutputTabElement(inputNum, active=false) { - return this.createTabElement(inputNum, active, "output"); - } - /** * Displays the tab bar for both the input and output */ showTabBar() { document.getElementById("input-tabs-wrapper").style.display = "block"; document.getElementById("output-tabs-wrapper").style.display = "block"; - document.getElementById("input-wrapper").classList.add("show-tabs"); document.getElementById("output-wrapper").classList.add("show-tabs"); - document.getElementById("save-all-to-file").style.display = "inline-block"; } @@ -221,10 +134,8 @@ class TabWaiter { hideTabBar() { document.getElementById("input-tabs-wrapper").style.display = "none"; document.getElementById("output-tabs-wrapper").style.display = "none"; - document.getElementById("input-wrapper").classList.remove("show-tabs"); document.getElementById("output-wrapper").classList.remove("show-tabs"); - document.getElementById("save-all-to-file").style.display = "none"; } @@ -271,30 +182,6 @@ class TabWaiter { } } - /** - * Refreshes the input tabs, and changes to activeTab - * - * @param {number[]} nums - The inputNums to be displayed as tabs - * @param {number} activeTab - The tab to change to - * @param {boolean} tabsLeft - True if there are input tabs to the left of the displayed tabs - * @param {boolean} tabsRight - True if there are input tabs to the right of the displayed tabs - */ - refreshInputTabs(nums, activeTab, tabsLeft, tabsRight) { - this.refreshTabs(nums, activeTab, tabsLeft, tabsRight, "input"); - } - - /** - * Refreshes the output tabs, and changes to activeTab - * - * @param {number[]} nums - The inputNums to be displayed as tabs - * @param {number} activeTab - The tab to change to - * @param {boolean} tabsLeft - True if there are output tabs to the left of the displayed tabs - * @param {boolean} tabsRight - True if there are output tabs to the right of the displayed tabs - */ - refreshOutputTabs(nums, activeTab, tabsLeft, tabsRight) { - this.refreshTabs(nums, activeTab, tabsLeft, tabsRight, "output"); - } - /** * Changes the active tab to a different tab * @@ -305,9 +192,6 @@ class TabWaiter { changeTab(inputNum, io) { const tabsList = document.getElementById(`${io}-tabs`); - this.manager.highlighter.removeHighlights(); - getSelection().removeAllRanges(); - let found = false; for (let i = 0; i < tabsList.children.length; i++) { const tabNum = parseInt(tabsList.children.item(i).getAttribute("inputNum"), 10); @@ -322,26 +206,6 @@ class TabWaiter { return found; } - /** - * Changes the active input tab to a different tab - * - * @param {number} inputNum - * @returns {boolean} - False if the tab is not currently being displayed - */ - changeInputTab(inputNum) { - return this.changeTab(inputNum, "input"); - } - - /** - * Changes the active output tab to a different tab - * - * @param {number} inputNum - * @returns {boolean} - False if the tab is not currently being displayed - */ - changeOutputTab(inputNum) { - return this.changeTab(inputNum, "output"); - } - /** * Updates the tab header to display a preview of the tab contents * @@ -361,26 +225,6 @@ class TabWaiter { tab.firstElementChild.innerText = headerData; } - /** - * Updates the input tab header to display a preview of the tab contents - * - * @param {number} inputNum - The inputNum of the tab to update the header of - * @param {string} data - The data to display in the tab header - */ - updateInputTabHeader(inputNum, data) { - this.updateTabHeader(inputNum, data, "input"); - } - - /** - * Updates the output tab header to display a preview of the tab contents - * - * @param {number} inputNum - The inputNum of the tab to update the header of - * @param {string} data - The data to display in the tab header - */ - updateOutputTabHeader(inputNum, data) { - this.updateTabHeader(inputNum, data, "output"); - } - /** * Updates the tab background to display the progress of the current tab * @@ -401,28 +245,6 @@ class TabWaiter { } } - /** - * Updates the input tab background to display its progress - * - * @param {number} inputNum - * @param {number} progress - * @param {number} total - */ - updateInputTabProgress(inputNum, progress, total) { - this.updateTabProgress(inputNum, progress, total, "input"); - } - - /** - * Updates the output tab background to display its progress - * - * @param {number} inputNum - * @param {number} progress - * @param {number} total - */ - updateOutputTabProgress(inputNum, progress, total) { - this.updateTabProgress(inputNum, progress, total, "output"); - } - } export default TabWaiter; diff --git a/src/web/waiters/TimingWaiter.mjs b/src/web/waiters/TimingWaiter.mjs new file mode 100644 index 00000000..88f281bb --- /dev/null +++ b/src/web/waiters/TimingWaiter.mjs @@ -0,0 +1,182 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2023 + * @license Apache-2.0 + */ + +/** + * Waiter to handle timing of the baking process. + */ +class TimingWaiter { + + /** + * TimingWaiter constructor. + * + * @param {App} app - The main view object for CyberChef. + * @param {Manager} manager - The CyberChef event manager. + */ + constructor(app, manager) { + this.app = app; + this.manager = manager; + + this.inputs = {}; + /* + Inputs example: + "1": { + "inputEncodingStart": 0, + "inputEncodingEnd": 0, + "trigger": 0 + "chefWorkerTasked": 0, + "bakeComplete": 0, + "bakeDuration": 0, + "settingOutput": 0, + "outputDecodingStart": 0, + "outputDecodingEnd": 0, + "complete": 0 + } + */ + } + + + /** + * Record the time for an input + * + * @param {string} event + * @param {number} inputNum + * @param {number} value + */ + recordTime(event, inputNum, value=Date.now()) { + inputNum = inputNum.toString(); + if (!Object.keys(this.inputs).includes(inputNum)) { + this.inputs[inputNum] = {}; + } + log.debug(`Recording ${event} for input ${inputNum}`); + this.inputs[inputNum][event] = value; + } + + /** + * The duration of the main stages of a bake + * + * @param {number} inputNum + * @returns {number} + */ + duration(inputNum) { + const input = this.inputs[inputNum.toString()]; + + // If this input has not been encoded yet, we cannot calculate a time + if (!input || + !input.trigger || + !input.inputEncodingEnd || + !input.inputEncodingStart) + return 0; + + // input encoding can happen before a bake is triggered, so it is calculated separately + const inputEncodingTotal = input.inputEncodingEnd - input.inputEncodingStart; + + let total = 0, outputDecodingTotal = 0; + + if (input.bakeComplete && input.bakeComplete > input.trigger) + total = input.bakeComplete - input.trigger; + + if (input.settingOutput && input.settingOutput > input.trigger) + total = input.settingOutput - input.trigger; + + if (input.outputDecodingStart && (input.outputDecodingStart > input.trigger) && + input.outputDecodingEnd && (input.outputDecodingEnd > input.trigger)) { + total = input.outputDecodingEnd - input.trigger; + outputDecodingTotal = input.outputDecodingEnd - input.outputDecodingStart; + } + + if (input.complete && input.complete > input.trigger) + total = inputEncodingTotal + input.bakeDuration + outputDecodingTotal; + + return total; + } + + /** + * The total time for a completed bake + * + * @param {number} inputNum + * @returns {number} + */ + overallDuration(inputNum) { + const input = this.inputs[inputNum.toString()]; + + // If this input has not been encoded yet, we cannot calculate a time + if (!input || + !input.trigger || + !input.inputEncodingEnd || + !input.inputEncodingStart) + return 0; + + // input encoding can happen before a bake is triggered, so it is calculated separately + const inputEncodingTotal = input.inputEncodingEnd - input.inputEncodingStart; + + let total = 0; + if (input.bakeComplete && input.bakeComplete > input.trigger) + total = input.bakeComplete - input.trigger; + + if (input.settingOutput && input.settingOutput > input.trigger) + total = input.settingOutput - input.trigger; + + if (input.outputDecodingStart && input.outputDecodingStart > input.trigger) + total = input.outputDecodingStart - input.trigger; + + if (input.outputDecodingEnd && input.outputDecodingEnd > input.trigger) + total = input.outputDecodingEnd - input.trigger; + + if (input.complete && input.complete > input.trigger) + total = input.complete - input.trigger; + + return total + inputEncodingTotal; + } + + /** + * Prints out the time between stages + * + * @param {number} inputNum + * @returns {string} + */ + printStages(inputNum) { + const input = this.inputs[inputNum.toString()]; + if (!input || !input.trigger) return ""; + + const total = this.overallDuration(inputNum), + inputEncoding = input.inputEncodingEnd - input.inputEncodingStart, + outputDecoding = input.outputDecodingEnd - input.outputDecodingStart, + overhead = total - inputEncoding - outputDecoding - input.bakeDuration; + + return `Input encoding: ${inputEncoding}ms +Recipe duration: ${input.bakeDuration}ms +Output decoding: ${outputDecoding}ms +Threading overhead: ${overhead}ms`; + } + + /** + * Logs every interval + * + * @param {number} inputNum + */ + logAllTimes(inputNum) { + const input = this.inputs[inputNum.toString()]; + if (!input || !input.trigger) return; + + try { + log.debug(`Trigger: ${input.trigger} +inputEncodingStart: ${input.inputEncodingStart} | ${input.inputEncodingStart - input.trigger}ms since trigger +inputEncodingEnd: ${input.inputEncodingEnd} | ${input.inputEncodingEnd - input.inputEncodingStart}ms input encoding time +chefWorkerTasked: ${input.chefWorkerTasked} | ${input.chefWorkerTasked - input.trigger}ms since trigger +bakeDuration: | ${input.bakeDuration}ms duration in worker +bakeComplete: ${input.bakeComplete} | ${input.bakeComplete - input.chefWorkerTasked}ms since worker tasked +settingOutput: ${input.settingOutput} | ${input.settingOutput - input.bakeComplete}ms since worker finished +outputDecodingStart: ${input.outputDecodingStart} | ${input.outputDecodingStart - input.settingOutput}ms since output set +outputDecodingEnd: ${input.outputDecodingEnd} | ${input.outputDecodingEnd - input.outputDecodingStart}ms output encoding time +complete: ${input.complete} | ${input.complete - input.outputDecodingEnd}ms since output decoded +Total: | ${input.complete - input.trigger}ms since trigger`); + } catch (err) {} + + } + +} + +export default TimingWaiter; diff --git a/src/web/waiters/WorkerWaiter.mjs b/src/web/waiters/WorkerWaiter.mjs index 7fcaa509..296aa956 100644 --- a/src/web/waiters/WorkerWaiter.mjs +++ b/src/web/waiters/WorkerWaiter.mjs @@ -72,6 +72,10 @@ class WorkerWaiter { this.dishWorker.worker = new DishWorker(); this.dishWorker.worker.addEventListener("message", this.handleDishMessage.bind(this)); + this.dishWorker.worker.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); if (this.dishWorkerQueue.length > 0) { this.postDishMessage(this.dishWorkerQueue.splice(0, 1)[0]); @@ -89,22 +93,27 @@ class WorkerWaiter { return -1; } - log.debug("Adding new ChefWorker"); + log.debug(`Adding new ChefWorker (${this.chefWorkers.length + 1}/${this.maxWorkers})`); // Create a new ChefWorker and send it the docURL const newWorker = new ChefWorker(); newWorker.addEventListener("message", this.handleChefMessage.bind(this)); + newWorker.postMessage({ + action: "setLogPrefix", + data: "ChefWorker" + }); + newWorker.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); + let docURL = document.location.href.split(/[#?]/)[0]; const index = docURL.lastIndexOf("/"); if (index > 0) { docURL = docURL.substring(0, index); } - newWorker.postMessage({"action": "docURL", "data": docURL}); - newWorker.postMessage({ - action: "setLogLevel", - data: log.getLevel() - }); + // Store the worker, whether or not it's active, and the inputNum as an object const newWorkerObj = { @@ -177,7 +186,7 @@ class WorkerWaiter { handleChefMessage(e) { const r = e.data; let inputNum = 0; - log.debug(`Receiving ${r.action} from ChefWorker.`); + log.debug(`Receiving '${r.action}' from ChefWorker.`); if (Object.prototype.hasOwnProperty.call(r.data, "inputNum")) { inputNum = r.data.inputNum; @@ -188,6 +197,8 @@ class WorkerWaiter { switch (r.action) { case "bakeComplete": log.debug(`Bake ${inputNum} complete.`); + this.manager.timing.recordTime("bakeComplete", inputNum); + this.manager.timing.recordTime("bakeDuration", inputNum, r.data.duration); if (r.data.error) { this.app.handleError(r.data.error); @@ -217,7 +228,7 @@ class WorkerWaiter { break; case "workerLoaded": this.app.workerLoaded = true; - log.debug("ChefWorker loaded."); + log.debug("ChefWorker loaded"); if (!this.loaded) { this.app.loaded(); this.loaded = true; @@ -266,7 +277,7 @@ class WorkerWaiter { if (progress !== false) { this.manager.output.updateOutputStatus("error", inputNum); - if (inputNum === this.manager.tabs.getActiveInputTab()) { + if (inputNum === this.manager.tabs.getActiveTab("input")) { this.manager.recipe.updateBreakpointIndicator(progress); } @@ -311,40 +322,68 @@ class WorkerWaiter { }; } + /** + * Cancels the current bake making it possible to autobake again + */ + cancelBakeForAutoBake() { + if (this.totalOutputs > 1) { + this.cancelBake(); + } else { + // In this case the UI changes can be skipped + + for (let i = this.chefWorkers.length - 1; i >= 0; i--) { + if (this.chefWorkers[i].active) { + this.removeChefWorker(this.chefWorkers[i]); + } + } + + this.inputs = []; + this.inputNums = []; + this.totalOutputs = 0; + this.loadingOutputs = 0; + } + } + /** * Cancels the current bake by terminating and removing all ChefWorkers * * @param {boolean} [silent=false] - If true, don't set the output - * @param {boolean} killAll - If true, kills all chefWorkers regardless of status + * @param {boolean} [killAll=false] - If true, kills all chefWorkers regardless of status */ - cancelBake(silent, killAll) { + cancelBake(silent=false, killAll=false) { + const deactiveOutputs = new Set(); + for (let i = this.chefWorkers.length - 1; i >= 0; i--) { if (this.chefWorkers[i].active || killAll) { const inputNum = this.chefWorkers[i].inputNum; this.removeChefWorker(this.chefWorkers[i]); - this.manager.output.updateOutputStatus("inactive", inputNum); + deactiveOutputs.add(inputNum); } } this.setBakingStatus(false); - for (let i = 0; i < this.inputs.length; i++) { - this.manager.output.updateOutputStatus("inactive", this.inputs[i].inputNum); - } + this.inputs.forEach(input => { + deactiveOutputs.add(input.inputNum); + }); - for (let i = 0; i < this.inputNums.length; i++) { - this.manager.output.updateOutputStatus("inactive", this.inputNums[i]); - } + this.inputNums.forEach(inputNum => { + deactiveOutputs.add(inputNum); + }); - const tabList = this.manager.tabs.getOutputTabList(); - for (let i = 0; i < tabList.length; i++) { - this.manager.tabs.getOutputTabItem(tabList[i]).style.background = ""; - } + deactiveOutputs.forEach(num => { + this.manager.output.updateOutputStatus("inactive", num); + }); + + const tabList = this.manager.tabs.getTabList("output"); + tabList.forEach(tab => { + this.manager.tabs.getTabItem(tab, "output").style.background = ""; + }); this.inputs = []; this.inputNums = []; this.totalOutputs = 0; this.loadingOutputs = 0; - if (!silent) this.manager.output.set(this.manager.tabs.getActiveOutputTab()); + if (!silent) this.manager.output.set(this.manager.tabs.getActiveTab("output")); } /** @@ -455,6 +494,7 @@ class WorkerWaiter { if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) { transferable = [input]; } + this.manager.timing.recordTime("chefWorkerTasked", nextInput.inputNum); this.chefWorkers[workerIdx].worker.postMessage({ action: "bake", data: { @@ -550,10 +590,12 @@ class WorkerWaiter { * @param {boolean} inputData.step - If true, only execute the next operation in the recipe * @param {number} inputData.progress - The current progress through the recipe. Used when stepping */ - async bakeAllInputs(inputData) { + async bakeInputs(inputData) { + log.debug(`Baking input list [${inputData.nums.join(",")}]`); + return await new Promise(resolve => { if (this.app.baking) return; - const inputNums = inputData.nums; + const inputNums = inputData.nums.filter(n => n > 0); const step = inputData.step; // Use cancelBake to clear out the inputs @@ -586,6 +628,7 @@ class WorkerWaiter { numBakes = this.inputNums.length; } for (let i = 0; i < numBakes; i++) { + this.manager.timing.recordTime("trigger", this.inputNums[0]); this.manager.input.inputWorker.postMessage({ action: "bakeNext", data: { @@ -595,6 +638,7 @@ class WorkerWaiter { }); this.loadingOutputs++; } + if (numBakes === 0) this.bakingComplete(); }); } @@ -626,7 +670,7 @@ class WorkerWaiter { */ handleDishMessage(e) { const r = e.data; - log.debug(`Receiving ${r.action} from DishWorker`); + log.debug(`Receiving '${r.action}' from DishWorker`); switch (r.action) { case "dishReturned": @@ -645,7 +689,7 @@ class WorkerWaiter { } /** - * Asks the ChefWorker to return the dish as the specified type + * Asks the DishWorker to return the dish as the specified type * * @param {Dish} dish * @param {string} type @@ -653,10 +697,9 @@ class WorkerWaiter { */ getDishAs(dish, type, callback) { const id = this.callbackID++; - this.callbacks[id] = callback; - if (this.dishWorker.worker === null) this.setupDishWorker(); + this.postDishMessage({ action: "getDishAs", data: { @@ -668,7 +711,7 @@ class WorkerWaiter { } /** - * Asks the ChefWorker to get the title of the dish + * Asks the DishWorker to get the title of the dish * * @param {Dish} dish * @param {number} maxLength @@ -677,9 +720,7 @@ class WorkerWaiter { */ getDishTitle(dish, maxLength, callback) { const id = this.callbackID++; - this.callbacks[id] = callback; - if (this.dishWorker.worker === null) this.setupDishWorker(); this.postDishMessage({ @@ -692,6 +733,29 @@ class WorkerWaiter { }); } + /** + * Asks the DishWorker to translate a buffer into a specific character encoding + * + * @param {ArrayBuffer} buffer + * @param {number} encoding + * @param {Function} callback + * @returns {string} + */ + bufferToStr(buffer, encoding, callback) { + const id = this.callbackID++; + this.callbacks[id] = callback; + if (this.dishWorker.worker === null) this.setupDishWorker(); + + this.postDishMessage({ + action: "bufferToStr", + data: { + buffer: buffer, + encoding: encoding, + id: id + } + }); + } + /** * Queues a message to be sent to the dishWorker * @@ -729,12 +793,18 @@ class WorkerWaiter { * Sets the console log level in the workers. */ setLogLevel() { - for (let i = 0; i < this.chefWorkers.length; i++) { - this.chefWorkers[i].worker.postMessage({ + this.chefWorkers.forEach(cw => { + cw.worker.postMessage({ action: "setLogLevel", data: log.getLevel() }); - } + }); + + if (!this.dishWorker.worker) return; + this.dishWorker.worker.postMessage({ + action: "setLogLevel", + data: log.getLevel() + }); } /** @@ -794,7 +864,7 @@ class WorkerWaiter { * * @param {Object[]} recipeConfig * @param {string} direction - * @param {Object} pos - The position object for the highlight. + * @param {Object[]} pos - The position object for the highlight. * @param {number} pos.start - The start offset. * @param {number} pos.end - The end offset. */ diff --git a/src/web/workers/DishWorker.mjs b/src/web/workers/DishWorker.mjs index a171fdad..662f3ffc 100644 --- a/src/web/workers/DishWorker.mjs +++ b/src/web/workers/DishWorker.mjs @@ -7,11 +7,21 @@ */ import Dish from "../../core/Dish.mjs"; +import DishError from "../../core/errors/DishError.mjs"; +import { CHR_ENC_SIMPLE_REVERSE_LOOKUP } from "../../core/lib/ChrEnc.mjs"; +import Utils from "../../core/Utils.mjs"; +import cptable from "codepage"; +import loglevelMessagePrefix from "loglevel-message-prefix"; + +loglevelMessagePrefix(log, { + prefixes: [], + staticPrefixes: ["DishWorker"] +}); self.addEventListener("message", function(e) { // Handle message from the main thread const r = e.data; - log.debug(`DishWorker receiving command '${r.action}'`); + log.debug(`Receiving command '${r.action}'`); switch (r.action) { case "getDishAs": @@ -20,8 +30,14 @@ self.addEventListener("message", function(e) { case "getDishTitle": getDishTitle(r.data); break; + case "bufferToStr": + bufferToStr(r.data); + break; + case "setLogLevel": + log.setLevel(r.data, false); + break; default: - log.error(`DishWorker sent invalid action: '${r.action}'`); + log.error(`Unknown action: '${r.action}'`); } }); @@ -67,3 +83,32 @@ async function getDishTitle(data) { } }); } + +/** + * Translates a buffer to a string using a specified encoding + * + * @param {object} data + * @param {ArrayBuffer} data.buffer + * @param {number} data.id + * @param {number} data.encoding + */ +async function bufferToStr(data) { + let str; + if (data.encoding === 0) { + str = Utils.arrayBufferToStr(data.buffer); + } else { + try { + str = cptable.utils.decode(data.encoding, new Uint8Array(data.buffer)); + } catch (err) { + str = new DishError(`Error decoding buffer with encoding ${CHR_ENC_SIMPLE_REVERSE_LOOKUP[data.encoding]}: ${err.message}`).toString(); + } + } + + self.postMessage({ + action: "dishReturned", + data: { + value: str, + id: data.id + } + }); +} diff --git a/src/web/workers/InputWorker.mjs b/src/web/workers/InputWorker.mjs index 9912995b..d687fc9f 100644 --- a/src/web/workers/InputWorker.mjs +++ b/src/web/workers/InputWorker.mjs @@ -3,21 +3,43 @@ * Handles storage, modification and retrieval of the inputs. * * @author j433866 [j433866@gmail.com] + * @author n1474335 [n1474335@gmail.com] * @copyright Crown Copyright 2019 * @license Apache-2.0 */ import Utils from "../../core/Utils.mjs"; -import {detectFileType} from "../../core/lib/FileType.mjs"; +import loglevelMessagePrefix from "loglevel-message-prefix"; + +loglevelMessagePrefix(log, { + prefixes: [], + staticPrefixes: ["InputWorker"] +}); // Default max values // These will be correctly calculated automatically self.maxWorkers = 4; self.maxTabs = 1; -self.pendingFiles = []; +/** + * Dictionary of inputs keyed on the inputNum + * Each entry is an object with the following type: + * @typedef {Object} Input + * @property {string} type + * @property {ArrayBuffer} buffer + * @property {string} stringSample + * @property {Object} file + * @property {string} file.name + * @property {number} file.size + * @property {string} file.type + * @property {string} status + * @property {number} progress + * @property {number} encoding + * @property {string} eolSequence + */ self.inputs = {}; self.loaderWorkers = []; +self.pendingFiles = []; self.currentInputNum = 1; self.numInputs = 0; self.pendingInputs = 0; @@ -35,7 +57,7 @@ self.addEventListener("message", function(e) { return; } - log.debug(`Receiving ${r.action} from InputWaiter.`); + log.debug(`Receiving command '${r.action}'`); switch (r.action) { case "loadUIFiles": @@ -53,9 +75,6 @@ self.addEventListener("message", function(e) { case "updateInputValue": self.updateInputValue(r.data); break; - case "updateInputObj": - self.updateInputObj(r.data); - break; case "updateInputProgress": self.updateInputProgress(r.data); break; @@ -75,7 +94,7 @@ self.addEventListener("message", function(e) { log.setLevel(r.data, false); break; case "addInput": - self.addInput(r.data, "string"); + self.addInput(r.data, "userinput"); break; case "refreshTabs": self.refreshTabs(r.data.inputNum, r.data.direction); @@ -98,9 +117,6 @@ self.addEventListener("message", function(e) { case "loaderWorkerMessage": self.handleLoaderMessage(r.data); break; - case "inputSwitch": - self.inputSwitch(r.data); - break; case "updateTabHeader": self.updateTabHeader(r.data); break; @@ -155,10 +171,10 @@ self.getLoadProgress = function(inputNum) { * whole recipe */ self.autoBake = function(inputNum, progress, step=false) { - const input = self.getInputObj(inputNum); + const input = self.inputs[inputNum]; if (input) { self.postMessage({ - action: "bakeAllInputs", + action: "bakeInputs", data: { nums: [parseInt(inputNum, 10)], step: step, @@ -173,16 +189,14 @@ self.autoBake = function(inputNum, progress, step=false) { * Sends a list of inputNums to the workerwaiter */ self.bakeAllInputs = function() { - const inputNums = Object.keys(self.inputs), - nums = []; + const inputNums = Object.keys(self.inputs); + + const nums = inputNums + .filter(n => self.inputs[n].status === "loaded") + .map(n => parseInt(n, 10)); - for (let i = 0; i < inputNums.length; i++) { - if (self.inputs[inputNums[i]].status === "loaded") { - nums.push(parseInt(inputNums[i], 10)); - } - } self.postMessage({ - action: "bakeAllInputs", + action: "bakeInputs", data: { nums: nums, step: false, @@ -198,7 +212,7 @@ self.bakeAllInputs = function() { * @param {number} bakeId */ self.bakeInput = function(inputNum, bakeId) { - const inputObj = self.getInputObj(inputNum); + const inputObj = self.inputs[inputNum]; if (inputObj === null || inputObj === undefined || inputObj.status !== "loaded") { @@ -213,46 +227,16 @@ self.bakeInput = function(inputNum, bakeId) { return; } - let inputData = inputObj.data; - if (typeof inputData !== "string") inputData = inputData.fileBuffer; - self.postMessage({ action: "queueInput", data: { - input: inputData, + input: inputObj.buffer, inputNum: inputNum, bakeId: bakeId } }); }; -/** - * Gets the stored object for a specific inputNum - * - * @param {number} inputNum - The input we want to get the object for - * @returns {object} - */ -self.getInputObj = function(inputNum) { - return self.inputs[inputNum]; -}; - -/** - * Gets the stored value for a specific inputNum. - * - * @param {number} inputNum - The input we want to get the value of - * @returns {string | ArrayBuffer} - */ -self.getInputValue = function(inputNum) { - if (self.inputs[inputNum]) { - if (typeof self.inputs[inputNum].data === "string") { - return self.inputs[inputNum].data; - } else { - return self.inputs[inputNum].data.fileBuffer; - } - } - return ""; -}; - /** * Gets the stored value or object for a specific inputNum and sends it to the inputWaiter. * @@ -262,12 +246,11 @@ self.getInputValue = function(inputNum) { * @param {number} inputData.id - The callback ID for the callback to run when returned to the inputWaiter */ self.getInput = function(inputData) { - const inputNum = inputData.inputNum, - data = (inputData.getObj) ? self.getInputObj(inputNum) : self.getInputValue(inputNum); + const input = self.inputs[inputData.inputNum]; self.postMessage({ action: "getInput", data: { - data: data, + data: inputData.getObj ? input : input.buffer, id: inputData.id } }); @@ -301,8 +284,8 @@ self.getInputNums = function(id) { * @returns {number | string} - Returns "error" if there was a load error */ self.getInputProgress = function(inputNum) { - const inputObj = self.getInputObj(inputNum); - if (inputObj === undefined || inputObj === null) return; + const inputObj = self.inputs[inputNum]; + if (!inputObj) return; if (inputObj.status === "error") { return "error"; } @@ -419,19 +402,17 @@ self.getNearbyNums = function(inputNum, direction) { * @param {number} inputNum - The inputNum of the tab header */ self.updateTabHeader = function(inputNum) { - const input = self.getInputObj(inputNum); - if (input === null || input === undefined) return; - let inputData = input.data; - if (typeof inputData !== "string") { - inputData = input.data.name; - } - inputData = inputData.replace(/[\n\r]/g, ""); + const input = self.inputs[inputNum]; + if (!input) return; + + let header = input.type === "file" ? input.file.name : input.stringSample; + header = header.slice(0, 100).replace(/[\n\r\u2028\u2029]/g, ""); self.postMessage({ action: "updateTabHeader", data: { inputNum: inputNum, - input: inputData.slice(0, 100) + input: header } }); }; @@ -445,42 +426,19 @@ self.updateTabHeader = function(inputNum) { * @param {boolean} inputData.silent - If false, the manager statechange event will be fired */ self.setInput = function(inputData) { - const inputNum = inputData.inputNum; - const silent = inputData.silent; - const input = self.getInputObj(inputNum); - if (input === undefined || input === null) return; + const {inputNum, silent} = inputData; + const input = self.inputs[inputNum]; + if (!input) return; - let inputVal = input.data; - const inputObj = { - inputNum: inputNum, - input: inputVal - }; - if (typeof inputVal !== "string") { - inputObj.name = inputVal.name; - inputObj.size = inputVal.size; - inputObj.type = inputVal.type; - inputObj.progress = input.progress; - inputObj.status = input.status; - inputVal = inputVal.fileBuffer; - const fileSlice = inputVal.slice(0, 512001); - inputObj.input = fileSlice; + self.postMessage({ + action: "setInput", + data: { + inputNum: inputNum, + inputObj: input, + silent: silent + } + }); - self.postMessage({ - action: "setInput", - data: { - inputObj: inputObj, - silent: silent - } - }, [fileSlice]); - } else { - self.postMessage({ - action: "setInput", - data: { - inputObj: inputObj, - silent: silent - } - }); - } self.updateTabHeader(inputNum); }; @@ -533,8 +491,7 @@ self.updateInputStatus = function(inputNum, status) { * @param {number} inputData.progress - The load progress of the input */ self.updateInputProgress = function(inputData) { - const inputNum = inputData.inputNum; - const progress = inputData.progress; + const {inputNum, progress} = inputData; if (self.inputs[inputNum] !== undefined) { self.inputs[inputNum].progress = progress; @@ -546,54 +503,31 @@ self.updateInputProgress = function(inputData) { * * @param {object} inputData * @param {number} inputData.inputNum - The input that's having its value updated - * @param {string | ArrayBuffer} inputData.value - The new value of the input - * @param {boolean} inputData.force - If true, still updates the input value if the input type is different to the stored value + * @param {ArrayBuffer} inputData.buffer - The new value of the input as a buffer + * @param {number} [inputData.encoding] - The character encoding of the input data + * @param {string} [inputData.eolSequence] - The end of line sequence of the input data + * @param {string} [inputData.stringSample] - A sample of the value as a string (truncated to 4096 chars) */ self.updateInputValue = function(inputData) { - const inputNum = inputData.inputNum; + const inputNum = parseInt(inputData.inputNum, 10); if (inputNum < 1) return; - if (Object.prototype.hasOwnProperty.call(self.inputs[inputNum].data, "fileBuffer") && - typeof inputData.value === "string" && !inputData.force) return; - const value = inputData.value; - if (self.inputs[inputNum] !== undefined) { - if (typeof value === "string") { - self.inputs[inputNum].data = value; - } else { - self.inputs[inputNum].data.fileBuffer = value; - } - self.inputs[inputNum].status = "loaded"; - self.inputs[inputNum].progress = 100; - return; + + if (!Object.prototype.hasOwnProperty.call(self.inputs, inputNum)) + throw new Error(`No input with ID ${inputNum} exists`); + + self.inputs[inputNum].buffer = inputData.buffer; + if ("encoding" in inputData) { + self.inputs[inputNum].encoding = inputData.encoding; } - - // If we get to here, an input for inputNum could not be found, - // so create a new one. Only do this if the value is a string, as - // loadFiles will create the input object for files - if (typeof value === "string") { - self.inputs.push({ - inputNum: inputNum, - data: value, - status: "loaded", - progress: 100 - }); + if ("eolSequence" in inputData) { + self.inputs[inputNum].eolSequence = inputData.eolSequence; } -}; - -/** - * Update the stored data object for an input. - * Used if we need to change a string to an ArrayBuffer - * - * @param {object} inputData - * @param {number} inputData.inputNum - The number of the input we're updating - * @param {object} inputData.data - The new data object for the input - */ -self.updateInputObj = function(inputData) { - const inputNum = inputData.inputNum; - const data = inputData.data; - - if (self.getInputObj(inputNum) === undefined) return; - - self.inputs[inputNum].data = data; + if (!("stringSample" in inputData)) { + inputData.stringSample = Utils.arrayBufferToStr(inputData.buffer.slice(0, 4096)); + } + self.inputs[inputNum].stringSample = inputData.stringSample; + self.inputs[inputNum].status = "loaded"; + self.inputs[inputNum].progress = 100; }; /** @@ -632,8 +566,7 @@ self.loaderWorkerReady = function(workerData) { /** * Handler for messages sent by loaderWorkers. - * (Messages are sent between the inputWorker and - * loaderWorkers via the main thread) + * (Messages are sent between the inputWorker and loaderWorkers via the main thread) * * @param {object} r - The data sent by the loaderWorker * @param {number} r.inputNum - The inputNum which the message corresponds to @@ -667,7 +600,7 @@ self.handleLoaderMessage = function(r) { self.updateInputValue({ inputNum: inputNum, - value: r.fileBuffer + buffer: r.fileBuffer }); self.postMessage({ @@ -752,12 +685,12 @@ self.terminateLoaderWorker = function(id) { * @param {number} filesData.activeTab - The active tab in the UI */ self.loadFiles = function(filesData) { - const files = filesData.files; - const activeTab = filesData.activeTab; + const {files, activeTab} = filesData; let lastInputNum = -1; const inputNums = []; for (let i = 0; i < files.length; i++) { - if (i === 0 && self.getInputValue(activeTab) === "") { + // If the first input is empty, replace it rather than adding a new one + if (i === 0 && (!self.inputs[activeTab].buffer || self.inputs[activeTab].buffer.byteLength === 0)) { self.removeInput({ inputNum: activeTab, refreshTabs: false, @@ -791,14 +724,14 @@ self.loadFiles = function(filesData) { } self.getLoadProgress(); - self.setInput({inputNum: activeTab, silent: true}); + self.setInput({inputNum: lastInputNum, silent: true}); }; /** * Adds an input to the input dictionary * * @param {boolean} [changetab=false] - Whether or not to change to the new input - * @param {string} type - Either "string" or "file" + * @param {string} type - Either "userinput" or "file" * @param {Object} fileData - Contains information about the file to be added to the input (only used when type is "file") * @param {string} fileData.name - The filename of the input being added * @param {number} fileData.size - The file size (in bytes) of the input being added @@ -810,25 +743,32 @@ self.addInput = function( type, fileData = { name: "unknown", - size: "unknown", + size: 0, type: "unknown" }, inputNum = self.currentInputNum++ ) { self.numInputs++; const newInputObj = { - inputNum: inputNum + type: null, + buffer: new ArrayBuffer(), + stringSample: "", + file: null, + status: "pending", + progress: 0, + encoding: 0, + eolSequence: "\u000a" }; switch (type) { - case "string": - newInputObj.data = ""; + case "userinput": + newInputObj.type = "userinput"; newInputObj.status = "loaded"; newInputObj.progress = 100; break; case "file": - newInputObj.data = { - fileBuffer: new ArrayBuffer(), + newInputObj.type = "file"; + newInputObj.file = { name: fileData.name, size: fileData.size, type: fileData.type @@ -837,7 +777,7 @@ self.addInput = function( newInputObj.progress = 0; break; default: - log.error(`Invalid type '${type}'.`); + log.error(`Invalid input type '${type}'.`); return -1; } self.inputs[inputNum] = newInputObj; @@ -976,18 +916,18 @@ self.filterTabs = function(searchData) { self.inputs[iNum].status === "loading" && showLoading || self.inputs[iNum].status === "loaded" && showLoaded) { try { - if (typeof self.inputs[iNum].data === "string") { + if (self.inputs[iNum].type === "userinput") { if (filterType.toLowerCase() === "content" && - filterExp.test(self.inputs[iNum].data.slice(0, 4096))) { - textDisplay = self.inputs[iNum].data.slice(0, 4096); + filterExp.test(self.inputs[iNum].stringSample)) { + textDisplay = self.inputs[iNum].stringSample; addInput = true; } } else { if ((filterType.toLowerCase() === "filename" && - filterExp.test(self.inputs[iNum].data.name)) || - filterType.toLowerCase() === "content" && - filterExp.test(Utils.arrayBufferToStr(self.inputs[iNum].data.fileBuffer.slice(0, 4096)))) { - textDisplay = self.inputs[iNum].data.name; + filterExp.test(self.inputs[iNum].file.name)) || + (filterType.toLowerCase() === "content" && + filterExp.test(self.inputs[iNum].stringSample))) { + textDisplay = self.inputs[iNum].file.name; addInput = true; } } @@ -1021,61 +961,3 @@ self.filterTabs = function(searchData) { data: inputs }); }; - -/** - * Swaps the input and outputs, and sends the old input back to the main thread. - * - * @param {object} switchData - * @param {number} switchData.inputNum - The inputNum of the input to be switched to - * @param {string | ArrayBuffer} switchData.outputData - The data to switch to - */ -self.inputSwitch = function(switchData) { - const currentInput = self.getInputObj(switchData.inputNum); - const currentData = currentInput.data; - if (currentInput === undefined || currentInput === null) return; - - if (typeof switchData.outputData !== "string") { - const output = new Uint8Array(switchData.outputData), - types = detectFileType(output); - let type = "unknown", - ext = "dat"; - if (types.length) { - type = types[0].mime; - ext = types[0].extension.split(",", 1)[0]; - } - - // ArrayBuffer - self.updateInputObj({ - inputNum: switchData.inputNum, - data: { - fileBuffer: switchData.outputData, - name: `output.${ext}`, - size: switchData.outputData.byteLength.toLocaleString(), - type: type - } - }); - } else { - // String - self.updateInputValue({ - inputNum: switchData.inputNum, - value: switchData.outputData, - force: true - }); - } - - self.postMessage({ - action: "inputSwitch", - data: { - data: currentData, - inputNum: switchData.inputNum - } - }); - - self.postMessage({ - action: "fileLoaded", - data: { - inputNum: switchData.inputNum - } - }); - -}; diff --git a/src/web/workers/LoaderWorker.js b/src/web/workers/LoaderWorker.js index 4c38998e..ef6280f0 100755 --- a/src/web/workers/LoaderWorker.js +++ b/src/web/workers/LoaderWorker.js @@ -6,32 +6,36 @@ * @license Apache-2.0 */ +import loglevelMessagePrefix from "loglevel-message-prefix"; + +loglevelMessagePrefix(log, { + prefixes: [], + staticPrefixes: ["LoaderWorker"] +}); + self.id = null; -self.handleMessage = function(e) { - const r = e.data; - log.debug(`LoaderWorker receiving command '${r.action}'`); - - switch (r.action) { - case "loadInput": - self.loadFile(r.data.file, r.data.inputNum); - break; - } -}; - - /** * Respond to message from parent thread. */ self.addEventListener("message", function(e) { + // Handle message const r = e.data; - if (Object.prototype.hasOwnProperty.call(r, "file") && Object.prototype.hasOwnProperty.call(r, "inputNum")) { - self.loadFile(r.file, r.inputNum); - } else if (Object.prototype.hasOwnProperty.call(r, "file")) { - self.loadFile(r.file, ""); - } else if (Object.prototype.hasOwnProperty.call(r, "id")) { - self.id = r.id; + log.debug(`Receiving command '${r.action}'`); + + switch (r.action) { + case "setID": + self.id = r.data.id; + break; + case "loadFile": + self.loadFile(r.data.file, r.data?.inputNum ?? ""); + break; + case "setLogLevel": + log.setLevel(r.data, false); + break; + default: + log.error(`Unknown action '${r.action}'.`); } }); diff --git a/src/web/workers/ZipWorker.mjs b/src/web/workers/ZipWorker.mjs index 85a8cb4c..f81e2b2c 100644 --- a/src/web/workers/ZipWorker.mjs +++ b/src/web/workers/ZipWorker.mjs @@ -10,6 +10,12 @@ import zip from "zlibjs/bin/zip.min.js"; import Utils from "../../core/Utils.mjs"; import Dish from "../../core/Dish.mjs"; import {detectFileType} from "../../core/lib/FileType.mjs"; +import loglevelMessagePrefix from "loglevel-message-prefix"; + +loglevelMessagePrefix(log, { + prefixes: [], + staticPrefixes: ["ZipWorker"], +}); const Zlib = zip.Zlib; @@ -17,17 +23,20 @@ const Zlib = zip.Zlib; * Respond to message from parent thread. */ self.addEventListener("message", function(e) { + // Handle message from the main thread const r = e.data; - if (!("outputs" in r)) { - log.error("No files were passed to the ZipWorker."); - return; - } - if (!("filename" in r)) { - log.error("No filename was passed to the ZipWorker"); - return; - } + log.debug(`Receiving command '${r.action}'`); - self.zipFiles(r.outputs, r.filename, r.fileExtension); + switch (r.action) { + case "zipFiles": + self.zipFiles(r.data.outputs, r.data.filename, r.data.fileExtension); + break; + case "setLogLevel": + log.setLevel(r.data, false); + break; + default: + log.error(`Unknown action: '${r.action}'`); + } }); self.setOption = function(...args) {}; diff --git a/tests/browser/nightwatch.js b/tests/browser/00_nightwatch.js similarity index 87% rename from tests/browser/nightwatch.js rename to tests/browser/00_nightwatch.js index 41aff9b2..e64b476b 100644 --- a/tests/browser/nightwatch.js +++ b/tests/browser/00_nightwatch.js @@ -6,6 +6,8 @@ * @license Apache-2.0 */ +const utils = require("./browserUtils.js"); + module.exports = { before: browser => { browser @@ -82,7 +84,7 @@ module.exports = { // Enter input browser .useCss() - .setValue("#input-text", "Don't Panic.") + .sendKeys("#input-text .cm-content", "Don't Panic.") .pause(1000) .click("#bake"); @@ -90,7 +92,7 @@ module.exports = { browser .useCss() .waitForElementNotVisible("#stale-indicator", 1000) - .expect.element("#output-text").to.have.property("value").that.equals("44 6f 6e 27 74 20 50 61 6e 69 63 2e"); + .expect.element("#output-text .cm-content").text.that.equals("44 6f 6e 27 74 20 50 61 6e 69 63 2e"); // Clear recipe browser @@ -192,6 +194,9 @@ module.exports = { // Open category browser + .useCss() + .waitForElementNotVisible("#snackbar-container", 10000) + .useXpath() .click(otherCat) .expect.element(genUUID).to.be.visible; @@ -206,7 +211,7 @@ module.exports = { .useCss() .waitForElementVisible(".operation .op-title", 1000) .waitForElementNotVisible("#stale-indicator", 1000) - .expect.element("#output-text").to.have.property("value").which.matches(/[\da-f-]{36}/); + .expect.element("#output-text .cm-content").text.which.matches(/[\da-f-]{36}/); browser.click("#clr-recipe"); }, @@ -221,6 +226,25 @@ module.exports = { .waitForElementVisible("//ul[@id='search-results']//b[text()='MD5']", 1000); }, + "Alert bar": browser => { + // Bake nothing to create an empty output which can be copied + utils.clear(browser); + utils.bake(browser); + + // Alert bar shows and contains correct content + browser + .waitForElementNotVisible("#snackbar-container") + .click("#copy-output") + .waitForElementVisible("#snackbar-container .snackbar-content") + .expect.element("#snackbar-container .snackbar-content").text.to.equal("Copied raw output successfully."); + + // Alert bar disappears after the correct amount of time + // Should disappear after 2000ms + browser + .waitForElementNotPresent("#snackbar-container .snackbar-content", 2500) + .waitForElementNotVisible("#snackbar-container"); + }, + after: browser => { browser.end(); } diff --git a/tests/browser/01_io.js b/tests/browser/01_io.js new file mode 100644 index 00000000..cbfec083 --- /dev/null +++ b/tests/browser/01_io.js @@ -0,0 +1,753 @@ +/** + * Tests for input and output of various types to ensure the editors work as expected + * and retain data integrity, especially when it comes to special characters. + * + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2023 + * @license Apache-2.0 + */ + +// import { +// clear, +// utils.setInput, +// bake, +// setChrEnc, +// setEOLSeq, +// copy, +// paste, +// loadRecipe, +// expectOutput, +// uploadFile, +// uploadFolder +// } from "./browserUtils.js"; + +const utils = require("./browserUtils.js"); + +const SPECIAL_CHARS = [ + "\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009\u000a\u000b\u000c\u000d\u000e\u000f", + "\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f", + "\u007f", + "\u0080\u0081\u0082\u0083\u0084\u0085\u0086\u0087\u0088\u0089\u008a\u008b\u008c\u008d\u008e\u008f", + "\u0090\u0091\u0092\u0093\u0094\u0095\u0096\u0097\u0098\u0099\u009a\u009b\u009c\u009d\u009e\u009f", + "\u00ad\u061c\u200b\u200e\u200f\u2028\u2029\u202d\u202e\u2066\u2067\u2069\ufeff\ufff9\ufffa\ufffb\ufffc" +].join(""); + +const ALL_BYTES = [ + "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", + "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", + "\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f", + "\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f", + "\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f", + "\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f", + "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f", + "\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f", + "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f", + "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f", + "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf", + "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf", + "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf", + "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf", + "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef", + "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff", +].join(""); + +const PUA_CHARS = "\ue000\ue001\uf8fe\uf8ff"; + +const MULTI_LINE_STRING =`"You know," said Arthur, "it's at times like this, when I'm trapped in a Vogon airlock with a man from Betelgeuse, and about to die of asphyxiation in deep space that I really wish I'd listened to what my mother told me when I was young." +"Why, what did she tell you?" +"I don't know, I didn't listen."`; + +const SELECTABLE_STRING = `ONE +two +ONE +three +ONE +four +ONE`; + +// Descriptions for named control characters +const CONTROL_CHAR_NAMES = { + 0: "null", + 7: "bell", + 8: "backspace", + 10: "line feed", + 11: "vertical tab", + 13: "carriage return", + 27: "escape", + 8203: "zero width space", + 8204: "zero width non-joiner", + 8205: "zero width joiner", + 8206: "left-to-right mark", + 8207: "right-to-left mark", + 8232: "line separator", + 8237: "left-to-right override", + 8238: "right-to-left override", + 8294: "left-to-right isolate", + 8295: "right-to-left isolate", + 8297: "pop directional isolate", + 8233: "paragraph separator", + 65279: "zero width no-break space", + 65532: "object replacement" +}; + +module.exports = { + before: browser => { + browser + .resizeWindow(1280, 800) + .url(browser.launchUrl) + .useCss() + .waitForElementNotPresent("#preloader", 10000) + .click("#auto-bake-label"); + }, + + "CodeMirror has loaded correctly": browser => { + /* Editor has initialised */ + browser + .useCss() + // Input + .waitForElementVisible("#input-text") + .waitForElementVisible("#input-text .cm-editor") + .waitForElementVisible("#input-text .cm-editor .cm-scroller") + .waitForElementVisible("#input-text .cm-editor .cm-scroller .cm-content") + .waitForElementVisible("#input-text .cm-editor .cm-scroller .cm-content .cm-line") + // Output + .waitForElementVisible("#output-text") + .waitForElementVisible("#output-text .cm-editor") + .waitForElementVisible("#output-text .cm-editor .cm-scroller") + .waitForElementVisible("#output-text .cm-editor .cm-scroller .cm-content") + .waitForElementVisible("#output-text .cm-editor .cm-scroller .cm-content .cm-line"); + + /* Status bar is showing and has correct values */ + browser // Input + .waitForElementVisible("#input-text .cm-status-bar") + .waitForElementVisible("#input-text .cm-status-bar .stats-length-value") + .expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("0"); + browser.waitForElementVisible("#input-text .cm-status-bar .stats-lines-value") + .expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + browser.waitForElementVisible("#input-text .cm-status-bar .chr-enc-value") + .expect.element("#input-text .cm-status-bar .chr-enc-value").text.to.equal("Raw Bytes"); + browser.waitForElementVisible("#input-text .cm-status-bar .eol-value") + .expect.element("#input-text .cm-status-bar .eol-value").text.to.equal("LF"); + + browser // Output + .waitForElementVisible("#output-text .cm-status-bar") + .waitForElementVisible("#output-text .cm-status-bar .stats-length-value") + .expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("0"); + browser.waitForElementVisible("#output-text .cm-status-bar .stats-lines-value") + .expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + browser.waitForElementVisible("#output-text .cm-status-bar .baking-time-info") + .expect.element("#output-text .cm-status-bar .baking-time-info").text.to.contain("ms"); + browser.waitForElementVisible("#output-text .cm-status-bar .chr-enc-value") + .expect.element("#output-text .cm-status-bar .chr-enc-value").text.to.equal("Raw Bytes"); + browser.waitForElementVisible("#output-text .cm-status-bar .eol-value") + .expect.element("#output-text .cm-status-bar .eol-value").text.to.equal("LF"); + }, + + "Adding content": browser => { + /* Status bar updates correctly */ + utils.setInput(browser, MULTI_LINE_STRING); + + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("3"); + browser.expect.element("#input-text .cm-status-bar .chr-enc-value").text.to.equal("Raw Bytes"); + browser.expect.element("#input-text .cm-status-bar .eol-value").text.to.equal("LF"); + + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("0"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + browser.expect.element("#output-text .cm-status-bar .baking-time-info").text.to.contain("ms"); + browser.expect.element("#output-text .cm-status-bar .chr-enc-value").text.to.equal("Raw Bytes"); + browser.expect.element("#output-text .cm-status-bar .eol-value").text.to.equal("LF"); + + /* Output updates correctly */ + utils.bake(browser); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("3"); + browser.expect.element("#output-text .cm-status-bar .baking-time-info").text.to.contain("ms"); + browser.expect.element("#output-text .cm-status-bar .chr-enc-value").text.to.equal("Raw Bytes"); + browser.expect.element("#output-text .cm-status-bar .eol-value").text.to.equal("LF"); + }, + + "Autobaking the latest input": browser => { + // Use the sleep recipe to simulate a long running task + utils.loadRecipe(browser, "Sleep", "input", [2000]); + + browser.waitForElementVisible("#stale-indicator"); + + // Enable previously disabled autobake + browser.expect.element("#auto-bake").to.not.be.selected; + browser.click("#auto-bake-label"); + browser.expect.element("#auto-bake").to.be.selected.before(1000); + + // Add content to the input + browser.pause(100); + browser.sendKeys("#input-text .cm-content", "1"); + browser.waitForElementVisible("#output-loader"); + browser.pause(500); + + // Make another change while the previous input is being baked + browser + .sendKeys("#input-text .cm-content", "2") + .waitForElementNotVisible("#stale-indicator") + .waitForElementNotVisible("#output-loader"); + + // Ensure we got the latest input baked + utils.expectOutput(browser, "input12"); + + // Turn autobake off again + browser.click("#auto-bake-label"); + browser.expect.element("#auto-bake").to.not.be.selected.before(1000); + }, + + "Special content": browser => { + /* Special characters are rendered correctly */ + utils.setInput(browser, SPECIAL_CHARS, false); + + // First line + for (let i = 0x0; i <= 0x8; i++) { + browser.expect.element(`#input-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(${i+1})`) + .to.have.property("title").equals(`Control character ${CONTROL_CHAR_NAMES[i] || "0x" + i.toString(16)}`); + browser.expect.element(`#input-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(${i+1})`) + .text.to.equal(String.fromCharCode(0x2400 + i)); + } + + // Tab \u0009 + browser.expect.element(`#input-text .cm-line:nth-of-type(1)`).to.have.property("textContent").match(/\u0009$/); + + // Line feed \u000a + browser.expect.element(`#input-text .cm-line:nth-of-type(1)`).to.have.property("textContent").match(/^.{10}$/); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + // Second line + for (let i = 0x0b; i < SPECIAL_CHARS.length; i++) { + const index = SPECIAL_CHARS.charCodeAt(i); + const name = CONTROL_CHAR_NAMES[index] || "0x" + index.toString(16); + const value = index >= 32 ? "\u2022" : String.fromCharCode(0x2400 + index); + + browser.expect.element(`#input-text .cm-line:nth-of-type(2) .cm-specialChar:nth-of-type(${i-10})`) + .to.have.property("title").equals(`Control character ${name}`); + browser.expect.element(`#input-text .cm-line:nth-of-type(2) .cm-specialChar:nth-of-type(${i-10})`) + .text.to.equal(value); + } + + /* Output renders correctly */ + utils.setChrEnc(browser, "output", "UTF-8"); + utils.bake(browser); + + // First line + for (let i = 0x0; i <= 0x8; i++) { + browser.expect.element(`#output-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(${i+1})`) + .to.have.property("title").equals(`Control character ${CONTROL_CHAR_NAMES[i] || "0x" + i.toString(16)}`); + browser.expect.element(`#output-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(${i+1})`) + .text.to.equal(String.fromCharCode(0x2400 + i)); + } + + // Tab \u0009 + browser.expect.element(`#output-text .cm-line:nth-of-type(1)`).to.have.property("textContent").match(/\u0009$/); + + // Line feed \u000a + browser.expect.element(`#output-text .cm-line:nth-of-type(1)`).to.have.property("textContent").match(/^.{10}$/); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + // Second line + for (let i = 0x0b; i < SPECIAL_CHARS.length; i++) { + const index = SPECIAL_CHARS.charCodeAt(i); + const name = CONTROL_CHAR_NAMES[index] || "0x" + index.toString(16); + const value = index >= 32 ? "\u2022" : String.fromCharCode(0x2400 + index); + + browser.expect.element(`#output-text .cm-content .cm-line:nth-of-type(2) .cm-specialChar:nth-of-type(${i-10})`) + .to.have.property("title").equals(`Control character ${name}`); + browser.expect.element(`#output-text .cm-content .cm-line:nth-of-type(2) .cm-specialChar:nth-of-type(${i-10})`) + .text.to.equal(value); + } + + /* Bytes are rendered correctly */ + utils.setInput(browser, ALL_BYTES, false); + // Expect length to be 255, since one character is creating a newline + browser.expect.element(`#input-text .cm-content`).to.have.property("textContent").match(/^.{255}$/); + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("256"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + + /* PUA \ue000-\uf8ff */ + utils.setInput(browser, PUA_CHARS, false); + utils.setChrEnc(browser, "output", "UTF-8"); + utils.bake(browser); + + // Confirm input and output as expected + /* In order to render whitespace characters as control character pictures in the output, even + when they are the designated line separator, CyberChef sometimes chooses to represent them + internally using the Unicode Private Use Area (https://en.wikipedia.org/wiki/Private_Use_Areas). + See `Utils.escapeWhitespace()` for an example of this. + Therefore, PUA characters should be rendered normally in the Input but as control character + pictures in the output. + */ + browser.expect.element(`#input-text .cm-content`).to.have.property("textContent").match(/^\ue000\ue001\uf8fe\uf8ff$/); + browser.expect.element(`#output-text .cm-content`).to.have.property("textContent").match(/^\u2400\u2401\u3cfe\u3cff$/); + + /* Can be copied */ + utils.setInput(browser, SPECIAL_CHARS, false); + utils.setChrEnc(browser, "output", "UTF-8"); + utils.bake(browser); + + // Manual copy + browser + .doubleClick("#output-text .cm-content .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(1)") + .waitForElementVisible("#output-text .cm-selectionBackground"); + utils.copy(browser); + utils.paste(browser, "#search"); // Paste into search box as this won't mess with the values + + // Ensure that the values are as expected + browser.expect.element("#search").to.have.value.that.equals("\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008"); + browser.clearValue("#search"); + + // Raw copy + browser + .click("#copy-output") + .pause(100); + utils.paste(browser, "#search"); // Paste into search box as this won't mess with the values + + // Ensure that the values are as expected + browser.expect.element("#search").to.have.value.that.matches(/^\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009/); + browser.clearValue("#search"); + }, + + "HTML output": browser => { + /* Displays correctly */ + utils.loadRecipe(browser, "Entropy", ALL_BYTES); + utils.bake(browser); + + browser + .waitForElementVisible("#output-html") + .waitForElementVisible("#output-html #chart-area"); + + /* Status bar widgets are disabled */ + browser.expect.element("#output-text .cm-status-bar .disabled .stats-length-value").to.be.visible; + browser.expect.element("#output-text .cm-status-bar .disabled .stats-lines-value").to.be.visible; + browser.expect.element("#output-text .cm-status-bar .disabled .chr-enc-value").to.be.visible; + browser.expect.element("#output-text .cm-status-bar .disabled .eol-value").to.be.visible; + + /* Displays special chars correctly */ + utils.loadRecipe(browser, "To Table", ",\u0000\u0001\u0002\u0003\u0004", [",", "\\r\\n", false, "HTML"]); + utils.bake(browser); + + for (let i = 0x0; i <= 0x4; i++) { + browser.expect.element(`#output-html .cm-specialChar:nth-of-type(${i+1})`) + .to.have.property("title").equals(`Control character ${CONTROL_CHAR_NAMES[i] || "0x" + i.toString(16)}`); + browser.expect.element(`#output-html .cm-specialChar:nth-of-type(${i+1})`) + .text.to.equal(String.fromCharCode(0x2400 + i)); + } + + /* Can be copied */ + // Raw copy + browser + .click("#copy-output") + .pause(100); + utils.paste(browser, "#search"); // Paste into search box as this won't mess with the values + + // Ensure that the values are as expected + browser.expect.element("#search").to.have.value.that.matches(/\u0000\u0001\u0002\u0003\u0004/); + browser.clearValue("#search"); + }, + + "Highlighting": browser => { + utils.setInput(browser, SELECTABLE_STRING); + utils.bake(browser); + + /* Selecting input text also selects other instances in input and output */ + browser // Input + .click("#auto-bake-label") + .doubleClick("#input-text .cm-content .cm-line:nth-of-type(1)") + .waitForElementVisible("#input-text .cm-selectionLayer .cm-selectionBackground") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(1) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(2) .cm-selectionMatch") + .waitForElementVisible("#input-text .cm-content .cm-line:nth-of-type(3) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(4) .cm-selectionMatch") + .waitForElementVisible("#input-text .cm-content .cm-line:nth-of-type(5) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(6) .cm-selectionMatch") + .waitForElementVisible("#input-text .cm-content .cm-line:nth-of-type(7) .cm-selectionMatch"); + + browser // Output + .waitForElementVisible("#output-text .cm-selectionLayer .cm-selectionBackground") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(1) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(2) .cm-selectionMatch") + .waitForElementVisible("#output-text .cm-content .cm-line:nth-of-type(3) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(4) .cm-selectionMatch") + .waitForElementVisible("#output-text .cm-content .cm-line:nth-of-type(5) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(6) .cm-selectionMatch") + .waitForElementVisible("#output-text .cm-content .cm-line:nth-of-type(7) .cm-selectionMatch"); + + /* Selecting output text highlights in input */ + browser // Output + .click("#output-text") + .waitForElementNotPresent("#input-text .cm-selectionLayer .cm-selectionBackground") + .waitForElementNotPresent("#output-text .cm-selectionLayer .cm-selectionBackground") + .waitForElementNotPresent("#input-text .cm-content .cm-line .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line .cm-selectionMatch") + .doubleClick("#output-text .cm-content .cm-line:nth-of-type(7)") + .waitForElementVisible("#output-text .cm-selectionLayer .cm-selectionBackground") + .waitForElementVisible("#output-text .cm-content .cm-line:nth-of-type(1) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(2) .cm-selectionMatch") + .waitForElementVisible("#output-text .cm-content .cm-line:nth-of-type(3) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(4) .cm-selectionMatch") + .waitForElementVisible("#output-text .cm-content .cm-line:nth-of-type(5) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(6) .cm-selectionMatch") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(7) .cm-selectionMatch"); + + browser // Input + .waitForElementVisible("#input-text .cm-selectionLayer .cm-selectionBackground") + .waitForElementVisible("#input-text .cm-content .cm-line:nth-of-type(1) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(2) .cm-selectionMatch") + .waitForElementVisible("#input-text .cm-content .cm-line:nth-of-type(3) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(4) .cm-selectionMatch") + .waitForElementVisible("#input-text .cm-content .cm-line:nth-of-type(5) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(6) .cm-selectionMatch") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(7) .cm-selectionMatch"); + + // Turn autobake off again + browser.click("#auto-bake-label"); + }, + + "Character encoding": browser => { + const CHINESE_CHARS = "不要恐慌。"; + /* Dropup works */ + /* Selecting changes output correctly */ + utils.setInput(browser, CHINESE_CHARS, false); + utils.setChrEnc(browser, "input", "UTF-8"); + utils.bake(browser); + + /* Output encoding should be autodetected */ + browser + .waitForElementVisible("#snackbar-container .snackbar-content", 5000) + .expect.element("#snackbar-container .snackbar-content").text.to.equal("Output character encoding has been detected and changed to UTF-8"); + + utils.expectOutput(browser, CHINESE_CHARS); + + /* Change the output encoding manually to test for URL presence */ + utils.setChrEnc(browser, "output", "UTF-8"); + + /* Encodings appear in the URL */ + browser.assert.urlContains("ienc=65001"); + browser.assert.urlContains("oenc=65001"); + + /* Preserved when changing tabs */ + browser + .click("#btn-new-tab") + .waitForElementVisible("#input-tabs li:nth-of-type(2).active-input-tab"); + browser.expect.element("#input-text .chr-enc-value").text.that.equals("Raw Bytes"); + browser.expect.element("#output-text .chr-enc-value").text.that.equals("Raw Bytes"); + + utils.setChrEnc(browser, "input", "UTF-7"); + utils.setChrEnc(browser, "output", "UTF-7"); + + browser + .click("#input-tabs li:nth-of-type(1)") + .waitForElementVisible("#input-tabs li:nth-of-type(1).active-input-tab"); + browser.expect.element("#input-text .chr-enc-value").text.that.equals("UTF-8"); + browser.expect.element("#output-text .chr-enc-value").text.that.equals("UTF-8"); + + /* Try various encodings */ + // These are not meant to be realistic encodings for this data + utils.setInput(browser, CHINESE_CHARS, false); + utils.setChrEnc(browser, "input", "UTF-8"); + utils.setChrEnc(browser, "output", "UTF-16LE"); + utils.bake(browser); + utils.expectOutput(browser, "\uB8E4\uE88D\u81A6\u81E6\uE690\u8C85\u80E3"); + + utils.setChrEnc(browser, "output", "Simplified Chinese GBK"); + utils.bake(browser); + utils.expectOutput(browser, "\u6D93\u5D88\uFDFF\u93AD\u612D\u53A1\u9286\u0000"); + + utils.setChrEnc(browser, "input", "UTF-7"); + utils.bake(browser); + utils.expectOutput(browser, "+Tg0-+iYE-+YFA-+YUw-"); + + utils.setChrEnc(browser, "input", "Traditional Chinese Big5"); + utils.bake(browser); + utils.expectOutput(browser, "\u3043\u74B6\uFDFF\u7A3A\uFDFF"); + + utils.setChrEnc(browser, "output", "Windows-1251 Cyrillic"); + utils.bake(browser); + utils.expectOutput(browser, "\u00A4\u0408\u00ADn\u00AE\u0408\u00B7W\u040EC"); + }, + + "Line endings": browser => { + /* Dropup works */ + /* Selecting changes view in input */ + utils.setInput(browser, MULTI_LINE_STRING); + + // Line endings: LF + + // Input + browser + .waitForElementPresent("#input-text .cm-content .cm-line:nth-of-type(3)") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(4)") + .waitForElementNotPresent("#input-text .cm-content .cm-specialChar"); + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("3"); + + // Output + utils.bake(browser); + browser + .waitForElementPresent("#output-text .cm-content .cm-line:nth-of-type(3)") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(4)") + .waitForElementNotPresent("#output-text .cm-content .cm-specialChar"); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("3"); + + // Input EOL: VT + utils.setEOLSeq(browser, "input", "VT"); + + // Input + browser + .waitForElementPresent("#input-text .cm-content .cm-line:nth-of-type(1)") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementPresent("#input-text .cm-content .cm-specialChar"); + browser.expect.element("#input-text .cm-content .cm-specialChar").text.to.equal("␊"); + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + + // Output + utils.bake(browser); + browser + .waitForElementPresent("#output-text .cm-content .cm-line:nth-of-type(3)") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(4)") + .waitForElementNotPresent("#output-text .cm-content .cm-specialChar"); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("3"); + + // Output EOL: VT + utils.setEOLSeq(browser, "output", "VT"); + + // Input + browser + .waitForElementPresent("#input-text .cm-content .cm-line:nth-of-type(1)") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementPresent("#input-text .cm-content .cm-specialChar"); + browser.expect.element("#input-text .cm-content .cm-specialChar").text.to.equal("␊"); + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + + // Output + browser + .waitForElementPresent("#output-text .cm-content .cm-line:nth-of-type(1)") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementPresent("#output-text .cm-content .cm-specialChar"); + browser.expect.element("#output-text .cm-content .cm-specialChar").text.to.equal("␊"); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("301"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + + /* Adding new line ending changes output correctly */ + browser.sendKeys("#input-text .cm-content", browser.Keys.RETURN); + + // Input + browser + .waitForElementPresent("#input-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(3)"); + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("302"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + // Output + utils.bake(browser); + browser + .waitForElementPresent("#output-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(3)"); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("302"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + // Input EOL: CRLF + utils.setEOLSeq(browser, "input", "CRLF"); + // Output EOL: CR + utils.setEOLSeq(browser, "output", "CR"); + browser.sendKeys("#input-text .cm-content", browser.Keys.RETURN); + + // Input + browser + .waitForElementPresent("#input-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementNotPresent("#input-text .cm-content .cm-line:nth-of-type(3)") + .waitForElementPresent("#input-text .cm-content .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(3)"); + browser.expect.element("#input-text .cm-content .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(3)").text.to.equal("␋"); + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("304"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + // Output + utils.bake(browser); + browser + .waitForElementPresent("#output-text .cm-content .cm-line:nth-of-type(2)") + .waitForElementNotPresent("#output-text .cm-content .cm-line:nth-of-type(3)") + .waitForElementPresent("#output-text .cm-content .cm-line:nth-of-type(2) .cm-specialChar"); + browser.expect.element("#output-text .cm-content .cm-line:nth-of-type(2) .cm-specialChar").text.to.equal("␊"); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("304"); + browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + /* Line endings appear in the URL */ + browser.assert.urlContains("ieol=CRLF"); + browser.assert.urlContains("oeol=CR"); + + /* Preserved when changing tabs */ + browser + .click("#btn-new-tab") + .waitForElementVisible("#input-tabs li:nth-of-type(2).active-input-tab"); + browser.expect.element("#input-text .eol-value").text.that.equals("LF"); + browser.expect.element("#output-text .eol-value").text.that.equals("LF"); + + utils.setEOLSeq(browser, "input", "FF"); + utils.setEOLSeq(browser, "output", "LS"); + + browser + .click("#input-tabs li:nth-of-type(1)") + .waitForElementVisible("#input-tabs li:nth-of-type(1).active-input-tab"); + browser.expect.element("#input-text .eol-value").text.that.equals("CRLF"); + browser.expect.element("#output-text .eol-value").text.that.equals("CR"); + }, + + "File inputs": browser => { + utils.clear(browser); + + /* Side panel displays correct info */ + utils.uploadFile(browser, "files/TowelDay.jpeg"); + + browser + .waitForElementVisible("#input-text .cm-file-details") + .waitForElementVisible("#input-text .cm-file-details .file-details-toggle-shown") + .waitForElementVisible("#input-text .cm-file-details .file-details-thumbnail") + .waitForElementVisible("#input-text .cm-file-details .file-details-name") + .waitForElementVisible("#input-text .cm-file-details .file-details-size") + .waitForElementVisible("#input-text .cm-file-details .file-details-type") + .waitForElementVisible("#input-text .cm-file-details .file-details-loaded"); + browser.expect.element("#input-text .cm-file-details .file-details-name").text.that.equals("TowelDay.jpeg"); + browser.expect.element("#input-text .cm-file-details .file-details-size").text.that.equals("61,379 bytes"); + browser.expect.element("#input-text .cm-file-details .file-details-type").text.that.equals("image/jpeg"); + browser.expect.element("#input-text .cm-file-details .file-details-loaded").text.that.equals("100%"); + + /* Side panel can be hidden */ + browser + .click("#input-text .cm-file-details .file-details-toggle-shown") + .waitForElementNotPresent("#input-text .cm-file-details .file-details-toggle-shown") + .waitForElementVisible("#input-text .cm-file-details .file-details-toggle-hidden") + .expect.element("#input-text .cm-file-details").to.have.css("width").which.equals("1px"); + + browser + .click("#input-text .cm-file-details .file-details-toggle-hidden") + .waitForElementNotPresent("#input-text .cm-file-details .file-details-toggle-hidden") + .waitForElementVisible("#input-text .cm-file-details .file-details-toggle-shown") + .expect.element("#input-text .cm-file-details").to.have.css("width").which.equals("200px"); + }, + + "Folder inputs": browser => { + utils.clear(browser); + + /* Side panel displays correct info */ + utils.uploadFolder(browser, "files"); + + // Loop through tabs + for (let i = 1; i < 3; i++) { + browser + .click(`#input-tabs li:nth-of-type(${i})`) + .waitForElementVisible(`#input-tabs li:nth-of-type(${i}).active-input-tab`); + + browser + .waitForElementVisible("#input-text .cm-file-details") + .waitForElementVisible("#input-text .cm-file-details .file-details-toggle-shown") + .waitForElementVisible("#input-text .cm-file-details .file-details-thumbnail") + .waitForElementVisible("#input-text .cm-file-details .file-details-name") + .waitForElementVisible("#input-text .cm-file-details .file-details-size") + .waitForElementVisible("#input-text .cm-file-details .file-details-type") + .waitForElementVisible("#input-text .cm-file-details .file-details-loaded"); + + browser.getText("#input-text .cm-file-details .file-details-name", function(result) { + switch (result.value) { + case "TowelDay.jpeg": + browser.expect.element("#input-text .cm-file-details .file-details-name").text.that.equals("TowelDay.jpeg"); + browser.expect.element("#input-text .cm-file-details .file-details-size").text.that.equals("61,379 bytes"); + browser.expect.element("#input-text .cm-file-details .file-details-type").text.that.equals("image/jpeg"); + browser.expect.element("#input-text .cm-file-details .file-details-loaded").text.that.equals("100%"); + break; + case "Hitchhikers_Guide.jpeg": + browser.expect.element("#input-text .cm-file-details .file-details-name").text.that.equals("Hitchhikers_Guide.jpeg"); + browser.expect.element("#input-text .cm-file-details .file-details-size").text.that.equals("36,595 bytes"); + browser.expect.element("#input-text .cm-file-details .file-details-type").text.that.equals("image/jpeg"); + browser.expect.element("#input-text .cm-file-details .file-details-loaded").text.that.equals("100%"); + break; + default: + break; + } + }); + } + }, + + // "Loading from URL": browser => { + // utils.clear(browser); + + // /* Side panel displays correct info */ + // utils.uploadFile(browser, "files/TowelDay.jpeg"); + + // browser + // .waitForElementVisible("#input-text .cm-file-details") + // .waitForElementVisible("#input-text .cm-file-details .file-details-toggle-shown") + // .waitForElementVisible("#input-text .cm-file-details .file-details-thumbnail") + // .waitForElementVisible("#input-text .cm-file-details .file-details-name") + // .waitForElementVisible("#input-text .cm-file-details .file-details-size") + // .waitForElementVisible("#input-text .cm-file-details .file-details-type") + // .waitForElementVisible("#input-text .cm-file-details .file-details-loaded"); + + // /* Complex deep link populates the input correctly (encoding, eol, input) */ + // browser + // .urlHash("recipe=To_Base64('A-Za-z0-9%2B/%3D')&input=VGhlIHNoaXBzIGh1bmcgaW4gdGhlIHNreSBpbiBtdWNoIHRoZSBzYW1lIHdheSB0aGF0IGJyaWNrcyBkb24ndC4M&ienc=21866&oenc=1201&ieol=FF&oeol=PS") + // .waitForElementVisible("#rec-list li.operation"); + + // browser.expect.element(`#input-text .cm-content`).to.have.property("textContent").match(/^.{65}$/); + // browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("66"); + // browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + + // browser.expect.element("#input-text .chr-enc-value").text.that.equals("KOI8-U Ukrainian Cyrillic"); + // browser.expect.element("#output-text .chr-enc-value").text.that.equals("UTF-16BE"); + + // browser.expect.element("#input-text .eol-value").text.that.equals("FF"); + // browser.expect.element("#output-text .eol-value").text.that.equals("PS"); + + // utils.bake(browser); + + // browser.expect.element(`#output-text .cm-content`).to.have.property("textContent").match(/^.{44}$/); + // browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("44"); + // browser.expect.element("#output-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + // }, + + "Replace input with output": browser => { + /* Input is correctly populated */ + utils.loadRecipe(browser, "XOR", "The ships hung in the sky in much the same way that bricks don't.", [{ "option": "Hex", "string": "65" }, "Standard", false]); + utils.setChrEnc(browser, "input", "UTF-32LE"); + utils.setChrEnc(browser, "output", "UTF-7"); + utils.setEOLSeq(browser, "input", "CRLF"); + utils.setEOLSeq(browser, "output", "LS"); + + browser + .sendKeys("#input-text .cm-content", browser.Keys.RETURN) + .expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + utils.bake(browser); + + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("67"); + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("2"); + browser.expect.element("#input-text .chr-enc-value").text.that.equals("UTF-32LE"); + browser.expect.element("#input-text .eol-value").text.that.equals("CRLF"); + browser.expect.element("#output-text .cm-status-bar .stats-length-value").text.to.equal("268"); + + browser + .click("#switch") + .waitForElementVisible("#stale-indicator"); + + browser.expect.element("#input-text .cm-status-bar .stats-length-value").text.to.equal("268"); + + /* Special characters, encodings and line endings all as expected */ + browser.expect.element("#input-text .cm-status-bar .stats-lines-value").text.to.equal("1"); + browser.expect.element("#input-text .chr-enc-value").text.that.equals("UTF-7"); + browser.expect.element("#input-text .eol-value").text.that.equals("LS"); + browser.expect.element("#input-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(1)").text.to.equal("␍"); + browser.expect.element("#input-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(49)").text.to.equal("␑"); + browser.waitForElementNotPresent("#input-text .cm-line:nth-of-type(1) .cm-specialChar:nth-of-type(50)"); + }, + + + after: browser => { + browser.end(); + } +}; diff --git a/tests/browser/ops.js b/tests/browser/02_ops.js similarity index 50% rename from tests/browser/ops.js rename to tests/browser/02_ops.js index 73777c0b..896de7b0 100644 --- a/tests/browser/ops.js +++ b/tests/browser/02_ops.js @@ -1,11 +1,20 @@ /** - * Tests for operations to ensure they output something sensible where expected + * Tests for operations. + * The primary purpose for these test is to ensure that the operations + * output something vaguely expected (i.e. they aren't completely broken + * after a dependency update or changes to the UI), rather than to confirm + * that this output is actually accurate. Accuracy of output and testing + * of edge cases should be carried out in the operations test suite found + * in /tests/operations as this is much faster and easier to configure + * than the UI tests found here. * * @author n1474335 [n1474335@gmail.com] * @copyright Crown Copyright 2021 * @license Apache-2.0 */ +const utils = require("./browserUtils.js"); + module.exports = { before: browser => { browser @@ -25,40 +34,62 @@ module.exports = { testOp(browser, "AES Encrypt", "test input", "e42eb8fbfb7a98fff061cd2c1a794d92", [{"option": "Hex", "string": "00112233445566778899aabbccddeeff"}, {"option": "Hex", "string": "00000000000000000000000000000000"}, "CBC", "Raw", "Hex"]); testOp(browser, "AND", "test input", "4$04 $044", [{ "option": "Hex", "string": "34" }]); testOp(browser, "Add line numbers", "test input", "1 test input"); - testOp(browser, ["From Hex", "Add Text To Image", "To Base64"], Images.PNG_HEX, Images.PNG_CHEF_B64, [[], ["Chef", "Center", "Middle", 0, 0, 16], []]); + testOp(browser, ["From Hex", "Add Text To Image", "SHA2"], Images.PNG_HEX, "50cdf8ea483c55564a091650c2bccb4586f919b721e5fe9d6a61660505b4346d6ebdb2ef0cf075a7728cd84cb26ea3e477b5bd86a94a49a27d79423994afb60a", [[], ["Chef", "Center", "Middle", 0, 0, 16, "Roboto"], []]); + testOp(browser, ["From Hex", "Add Text To Image", "SHA2"], Images.PNG_HEX, "78b3055463d9167dd039e47f451acaf06c593d209f8e405b4e18011cdcf190dc0af5952be887d93c0ebd38738e978120c1294c71104e6b00d3f9de8d6320ec1c", [[], ["Chef", "Center", "Middle", 0, 0, 16, "Roboto Black"], []]); + testOp(browser, ["From Hex", "Add Text To Image", "SHA2"], Images.PNG_HEX, "4ab4d4b6cb22ad700f6cd144c2c8ecad2a094f21a1d1d5d48eb6c8f97417192f89b4512f6a78276d49668ebef5e89c3a4d14860cb79399a0dafce98c92209e07", [[], ["Chef", "Center", "Middle", 0, 0, 16, "Roboto Mono"], []]); + testOp(browser, ["From Hex", "Add Text To Image", "SHA2"], Images.PNG_HEX, "11490db4907516b4d9e256da1ac0b02b561fa7547971e6316a8a0b90c9c66585a11f3145672c6d972b1a221d3bfad9c8a97de7ff77fd9442ebc40f39c1ef9ef7", [[], ["Chef", "Center", "Middle", 0, 0, 16, "Roboto Slab"], []]); + testOp(browser, ["From Hex", "Dither Image", "SHA2"], Images.PNG_HEX, "cbf587a78915cfb14546ba83080b13e5054800802488dd0cb786b8951e7dc0b48f055260917bd0ccfc075e422b9d6aff112948562653995d74e70f0b66367ac3", [[], [], []]); + testOp(browser, ["From Hex", "Generate Image", "SHA2"], Images.PNG_HEX, "2c451762a6c9192fd31dc80765eab3f447be70ea51f6fdb6911ade4d89d4a98bd0a1ff00b08d76aac472faeceb54b66092e3f3be7bbf899bf3e55ca9c96a56aa", [[], [], []]); + testOp(browser, ["From Hex", "Image Hue/Saturation/Lightness", "SHA2"], Images.PNG_HEX, "522dfc0bbef00e05c5d6861a002039fa2952e4bbb7fe8d21d0d538ef6f9d65da82065929b4150dc5b8b49460ee6c9bef7f660b86f8d4e7442a07c61c0a152a4b", [[], [50, 50, 50], []]); + testOp(browser, ["From Hex", "Resize Image", "SHA2"], Images.PNG_HEX, "654bfbf0a0537c901459c4bc22c5fb0bacbf01af775a0733e3a1c46cda5b699bcc4ed85322d813c7bb9b245d62d64425c0766fe03d3d20bc63634e2a4df17626", [[], [64, 64], []]); testOp(browser, "Adler-32 Checksum", "test input", "16160411"); testOp(browser, "Affine Cipher Decode", "test input", "rcqr glnsr", [1, 2]); - testOp(browser, "Affine Cipher Encode", "test input", "njln rbfpn", [2, 1]); + testOp(browser, "Affine Cipher Encode", "test input", "gndg zoujg", [3, 1]); + testOp(browser, "AMF Decode", "\u000A\u0013\u0001\u0003a\u0006\u0009test", /"\$value": "test"/); + testOp(browser, "AMF Encode", '{"a": "test"}', "\u000A\u0013\u0001\u0003a\u0006\u0009test"); testOp(browser, "Analyse hash", "0123456789abcdef", /CRC-64/); testOp(browser, "Atbash Cipher", "test input", "gvhg rmkfg"); // testOp(browser, "Avro to JSON", "test input", "test_output"); - // testOp(browser, "BLAKE2b", "test input", "test_output"); - // testOp(browser, "BLAKE2s", "test input", "test_output"); - // testOp(browser, "BSON deserialise", "test input", "test_output"); - // testOp(browser, "BSON serialise", "test input", "test_output"); + testOp(browser, + [ + "From Hex", "Avro to JSON" + ], + "4f626a0104166176726f2e736368656d6196017b2274797065223a227265636f7264222c226e616d65223a22736d616c6c222c226669656c6473223a5b7b226e616d65223a226e616d65222c2274797065223a22737472696e67227d5d7d146176726f2e636f646563086e756c6c004e0247632e3702e5b75cdab9a62f1541020e0c6d796e616d654e0247632e3702e5b75cdab9a62f1541", + '{"name":"myname"}\n', + [[], [false]] + ); + testOp(browser, "BLAKE2b", "test input", "33ebdc8f38177f3f3f334eeb117a84e11f061bbca4db6b8923e5cec85103f59f415551a5d5a933fdb6305dc7bf84671c2540b463dbfa08ee1895cfaa5bd780b5", ["512", "Hex", { "option": "UTF8", "string": "pass" }]); + testOp(browser, "BLAKE2s", "test input", "defe73d61dfa6e5807e4f9643e159a09ccda6be3c26dcd65f8a9bb38bfc973a7", ["256", "Hex", { "option": "UTF8", "string": "pass" }]); + testOp(browser, "BSON deserialise", "\u0011\u0000\u0000\u0000\u0002a\u0000\u0005\u0000\u0000\u0000test\u0000\u0000", '{\u000A "a": "test"\u000A}'); + testOp(browser, "BSON serialise", '{"a":"test"}', "\u0011\u0000\u0000\u0000\u0002a\u0000\u0005\u0000\u0000\u0000test\u0000\u0000"); // testOp(browser, "Bacon Cipher Decode", "test input", "test_output"); // testOp(browser, "Bacon Cipher Encode", "test input", "test_output"); - // testOp(browser, "Bcrypt", "test input", "test_output"); - // testOp(browser, "Bcrypt compare", "test input", "test_output"); - // testOp(browser, "Bcrypt parse", "test input", "test_output"); - // testOp(browser, "Bifid Cipher Decode", "test input", "test_output"); - // testOp(browser, "Bifid Cipher Encode", "test input", "test_output"); - // testOp(browser, "Bit shift left", "test input", "test_output"); - // testOp(browser, "Bit shift right", "test input", "test_output"); + testOp(browser, "Bcrypt", "test input", /^\$2a\$06\$.{53}$/, [6]); + testOp(browser, "Bcrypt compare", "test input", "Match: test input", ["$2a$05$FCfBSVX7OeRkK.9kQVFCiOYu9XtwtIbePqUiroD1lkASW9q5QClzG"]); + testOp(browser, "Bcrypt parse", "$2a$05$kXWtAIGB/R8VEzInoM5ocOTBtyc0m2YTIwFiBU/0XoW032f9QrkWW", /Rounds: 5/); + testOp(browser, "Bifid Cipher Decode", "qblb tfovy", "test input", ["pass"]); + testOp(browser, "Bifid Cipher Encode", "test input", "qblb tfovy", ["pass"]); + testOp(browser, "Bit shift left", "test input", "\u00E8\u00CA\u00E6\u00E8@\u00D2\u00DC\u00E0\u00EA\u00E8"); + testOp(browser, "Bit shift right", "test input", ":29:\u0010478::"); testOp(browser, "Blowfish Decrypt", "10884e15427dd84ec35204e9c8e921ae", "test_output", [{"option": "Hex", "string": "1234567801234567"}, {"option": "Hex", "string": "0011223344556677"}, "CBC", "Hex", "Raw"]); testOp(browser, "Blowfish Encrypt", "test input", "f0fadbd1d90d774f714248cf26b96410", [{"option": "Hex", "string": "1234567801234567"}, {"option": "Hex", "string": "0011223344556677"}, "CBC", "Raw", "Hex"]); - testOp(browser, ["From Hex", "Blur Image", "To Base64"], Images.PNG_HEX, Images.PNG_BLUR_B64); - // testOp(browser, "Bombe", "test input", "test_output"); + testOp(browser, ["From Hex", "Blur Image", "SHA2"], Images.PNG_HEX, "24f2e89f3e00cc35f551bbc48ea82e76474946ce0282183494d1ca3d3b0012c27b6102c4368ae056dc7fecb6df7886d86ff3d29b7e5965493f30c371eee9a24e"); + testOp(browser, ["From Hex", "Blur Image", "SHA2"], Images.PNG_HEX, "2c49d89fc10c94352c9a19f82de353c37928831d6f976a6b36eb918825a0ba027980801838228a4a0da63f1886e4fa59b6666f992ad2d2b7d4622253dc034052", [[], [5, "Gaussian"], []]); + testOp(browser, ["From Hex", "Sharpen Image", "SHA2"], Images.PNG_HEX, "acc7027642c2eeb67d7356a80ed8a1bdce9adabf656ea1294e47723f506626a7aa41f1660fa844a1e1e83b17180017ab0d5bccd7f6a341692832020dc887eaa5"); + testOp(browser, ["From Hex", "Contain Image", "SHA2"], Images.PNG_HEX, "cb871ad0722d487d56a2b18247b1aa30ecc244eb717e08e23a55cae78759553312dc1717196d7cb9daa04743e57c56fc3901ba92be5a68fb03c377f718e8efe7"); + testOpHtml(browser, "Bombe", "XTSYN WAEUG EZALY NRQIM AMLZX MFUOD AWXLY LZCUZ QOQBQ JLCPK NDDRW F", "table tr:last-child td:first-child", "ECG", ["3-rotor", "LEYJVCNIXWPBQMDRTAKZGFUHOS", "BDFHJLCPRTXVZNYEIWGAKMUSQO
Key: Triple DES uses a key length of 24 bytes (192 bits).
DES uses a key length of 8 bytes (64 bits).
IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
Padding: In CBC and ECB mode, PKCS#7 padding will be used as a default."); + assert.strictEqual(result[0].description, "Triple DES applies DES three times to each block to increase key size.
Key: Triple DES uses a key length of 24 bytes (192 bits).
IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
Padding: In CBC and ECB mode, PKCS#7 padding will be used as a default."); assert.strictEqual(result[0].args.length, 5); }), @@ -136,7 +136,7 @@ TestRegister.addApiTests([ it("chef.help: returns multiple results", () => { const result = chef.help("base 64"); - assert.strictEqual(result.length, 11); + assert.strictEqual(result.length, 13); }), it("chef.help: looks in description for matches too", () => { @@ -345,6 +345,42 @@ TestRegister.addApiTests([ assert.strictEqual(result.toString(), "begin_something_aaaaaaaaaaaaaa_end_something"); }), + it("chef.bake: should accept operation names from Chef Website which contain forward slash", () => { + const result = chef.bake("I'll have the test salmon", [ + { "op": "Find / Replace", + "args": [{ "option": "Regex", "string": "test" }, "good", true, false, true, false]} + ]); + assert.strictEqual(result.toString(), "I'll have the good salmon"); + }), + + it("chef.bake: should accept operation names from Chef Website which contain a hyphen", () => { + const result = chef.bake("I'll have the test salmon", [ + { "op": "Adler-32 Checksum", + "args": [] } + ]); + assert.strictEqual(result.toString(), "6e4208f8"); + }), + + it("chef.bake: should accept operation names from Chef Website which contain a period", () => { + const result = chef.bake("30 13 02 01 05 16 0e 41 6e 79 62 6f 64 79 20 74 68 65 72 65 3f", [ + { "op": "Parse ASN.1 hex string", + "args": [0, 32] } + ]); + assert.strictEqual(result.toString(), `SEQUENCE + INTEGER 05 + IA5String 'Anybody there?' +`); + }), + + it("Excluded operations: throw a sensible error when you try and call one", () => { + try { + chef.fork(); + } catch (e) { + assert.strictEqual(e.type, "ExcludedOperationError"); + assert.strictEqual(e.message, "Sorry, the Fork operation is not available in the Node.js version of CyberChef."); + } + }), + it("chef.bake: cannot accept flowControl operations in recipe", () => { assert.throws(() => chef.bake("some input", "magic"), { name: "TypeError", diff --git a/tests/node/tests/operations.mjs b/tests/node/tests/operations.mjs index 783bd00a..a97f5ccb 100644 --- a/tests/node/tests/operations.mjs +++ b/tests/node/tests/operations.mjs @@ -45,10 +45,10 @@ TestRegister.addApiTests([ const result = chef.ADD("sample input", { key: { string: "some key", - option: "Hex" + option: "utf8" } }); - assert.equal(result.toString(), "aO[^ZS\u000eW\\^cb"); + assert.equal(result.toString(), "\xe6\xd0\xda\xd5\x8c\xd0\x85\xe2\xe1\xdf\xe2\xd9"); }), @@ -121,10 +121,10 @@ Tiger-128`; const result = chef.AND("Scot-free", { key: { string: "Raining Cats and Dogs", - option: "Hex", + option: "utf8", } }); - assert.strictEqual(result.toString(), "\u0000\"M$(D E"); + assert.strictEqual(result.toString(), "Raid)fb A"); }), it("atBash Cipher", () => { @@ -305,16 +305,6 @@ Full hash: $2a$10$ODeP1.6fMsb.ENk2ngPUCO7qTGVPyHA9TqDVcyupyed8FjsiF65L6`; assert.strictEqual(result.toString(), "2"); }), - it("CRC16 Checksum", () => { - const result = chef.CRC16Checksum("Rain on Your Parade"); - assert.strictEqual(result.toString(), "db1c"); - }), - - it("CRC32 Checksum", () => { - const result = chef.CRC32Checksum("Rain on Your Parade"); - assert.strictEqual(result.toString(), "e902f76c"); - }), - it("CSS Beautify", () => { const result = chef.CSSBeautify("header {color:black;padding:3rem;}"); const expected = `header { @@ -371,10 +361,10 @@ color: white; }, salt: { string: "Market", - option: "Hex", + option: "utf8", }, }); - assert.strictEqual(result.toString(), "7c21a9f5063a4d62fb1050068245c181"); + assert.strictEqual(result.toString(), "4930d5d200e80f18c96b5550d13c6af8"); }), it("Derive PBKDF2 Key", () => { @@ -432,7 +422,7 @@ color: white; it("Disassemble x86", () => { const result = chef.disassembleX86(chef.toBase64("one two three")); const expected = `0000000000000000 0000 ADD BYTE PTR [RAX],AL\r -0000000000000002 0B250000000B OR ESP,DWORD PTR [0000000-F4FFFFF8]\r +0000000000000002 0B250000000B OR ESP,DWORD PTR [000000000B000008]\r `; assert.strictEqual(result.toString(), expected); }), @@ -575,12 +565,11 @@ Top Drawer`, { }), it("Generate HOTP", () => { - const result = chef.generateHOTP("Cut The Mustard", { - name: "colonel", + const result = chef.generateHOTP("JBSWY3DPEHPK3PXP", { }); - const expected = `URI: otpauth://hotp/colonel?secret=IN2XIICUNBSSATLVON2GC4TE + const expected = `URI: otpauth://hotp/?secret=JBSWY3DPEHPK3PXP&algorithm=SHA1&digits=6&counter=0 -Password: 034148`; +Password: 282760`; assert.strictEqual(result.toString(), expected); }), @@ -591,10 +580,24 @@ Password: 034148`; assert.strictEqual(result.toString().substr(0, 37), "-----BEGIN PGP PRIVATE KEY BLOCK-----"); }), - it("Generate UUID", () => { - const result = chef.generateUUID(); - assert.ok(result.toString()); - assert.strictEqual(result.toString().length, 36); + ...[1, 3, 4, 5, 6, 7].map(version => it(`Generate UUID v${version}`, () => { + const result = chef.generateUUID("", { "version": `v${version}` }).toString(); + assert.ok(result); + assert.strictEqual(result.length, 36); + })), + + ...[1, 3, 4, 5, 6, 7].map(version => it(`Analyze UUID v${version}`, () => { + const uuid = chef.generateUUID("", { "version": `v${version}` }).toString(); + const result = chef.analyseUUID(uuid).toString(); + assert.ok(result.startsWith(`Version:\n${version}\n`), `Expected output to start with "Version:\\n${version}\\n", got: ${result}`); + })), + + it("Generate UUID using defaults", () => { + const uuid = chef.generateUUID(); + assert.ok(uuid); + + const analysis = chef.analyseUUID(uuid).toString(); + assert.ok(analysis.startsWith("Version:\n4\n"), `Expected output to start with "Version:\\n4\\n", got: ${analysis}`); }), it("Gzip, Gunzip", () => { @@ -635,6 +638,10 @@ WWFkYSBZYWRh\r assert.strictEqual(chef.keccak("Flea Market").toString(), "c2a06880b19e453ee5440e8bd4c2024bedc15a6630096aa3f609acfd2b8f15f27cd293e1cc73933e81432269129ce954a6138889ce87831179d55dcff1cc7587"); }), + it("LZNT1 Decompress", () => { + assert.strictEqual(chef.LZNT1Decompress("\x1a\xb0\x00compress\x00edtestda\x04ta\x07\x88alot").toString(), "compressedtestdatacompressedalot"); + }), + it("MD6", () => { assert.strictEqual(chef.MD6("Head Over Heels", {key: "arty"}).toString(), "d8f7fe4931fbaa37316f76283d5f615f50ddd54afdc794b61da522556aee99ad"); }), @@ -859,13 +866,15 @@ pCGTErs= }), it("SQL Beautify", () => { - const result = chef.SQLBeautify(`SELECT MONTH, ID, RAIN_I, TEMP_F -FROM STATS;`); - const expected = `SELECT MONTH, - ID, - RAIN_I, - TEMP_F -FROM STATS;`; + const result = chef.SQLBeautify(`SELECT MONTH, ID, RAIN_I, TEMP_F FROM STATS;`); + const expected = +`SELECT + MONTH, + ID, + RAIN_I, + TEMP_F +FROM + STATS;`; assert.strictEqual(result.toString(), expected); }), diff --git a/tests/operations/index.mjs b/tests/operations/index.mjs index 141f35de..71221cc1 100644 --- a/tests/operations/index.mjs +++ b/tests/operations/index.mjs @@ -4,7 +4,7 @@ * @author john [john19696@protonmail.com] * @author tlwr [toby@toby.codes] * @author n1474335 [n1474335@gmail.com] -* @copyright Crown Copyright 2022 +* @copyright Crown Copyright 2026 * @license Apache-2.0 */ @@ -14,31 +14,42 @@ import { } from "../lib/utils.mjs"; import TestRegister from "../lib/TestRegister.mjs"; +import "./tests/A1Z26CipherDecode.mjs"; +import "./tests/AESKeyWrap.mjs"; +import "./tests/AlternatingCaps.mjs"; +import "./tests/AnalyseUUID.mjs"; import "./tests/AvroToJSON.mjs"; import "./tests/BCD.mjs"; import "./tests/BLAKE2b.mjs"; import "./tests/BLAKE2s.mjs"; +import "./tests/BLAKE3.mjs"; import "./tests/BSON.mjs"; import "./tests/BaconCipher.mjs"; +import "./tests/Base32.mjs"; import "./tests/Base45.mjs"; import "./tests/Base58.mjs"; import "./tests/Base62.mjs"; import "./tests/Base64.mjs"; import "./tests/Base85.mjs"; +import "./tests/Base92.mjs"; +import "./tests/Bech32.mjs"; import "./tests/BitwiseOp.mjs"; import "./tests/Bombe.mjs"; import "./tests/ByteRepr.mjs"; import "./tests/CBORDecode.mjs"; import "./tests/CBOREncode.mjs"; +import "./tests/CMAC.mjs"; +import "./tests/CRCChecksum.mjs"; import "./tests/CSV.mjs"; import "./tests/CaesarBoxCipher.mjs"; +import "./tests/CaretMdecode.mjs"; import "./tests/CartesianProduct.mjs"; import "./tests/CetaceanCipherDecode.mjs"; import "./tests/CetaceanCipherEncode.mjs"; +import "./tests/ChaCha.mjs"; import "./tests/ChangeIPFormat.mjs"; import "./tests/CharEnc.mjs"; import "./tests/Charts.mjs"; -import "./tests/Checksum.mjs"; import "./tests/CipherSaber2.mjs"; import "./tests/Ciphers.mjs"; import "./tests/Code.mjs"; @@ -47,79 +58,137 @@ import "./tests/Comment.mjs"; import "./tests/Compress.mjs"; import "./tests/ConditionalJump.mjs"; import "./tests/ConvertCoordinateFormat.mjs"; +import "./tests/ConvertLeetSpeak.mjs"; import "./tests/ConvertToNATOAlphabet.mjs"; import "./tests/Crypt.mjs"; import "./tests/DateTime.mjs"; import "./tests/DefangIP.mjs"; +import "./tests/DisassembleARM.mjs"; +import "./tests/DropNthBytes.mjs"; +import "./tests/ECDSA.mjs"; import "./tests/ELFInfo.mjs"; import "./tests/Enigma.mjs"; +import "./tests/ExtractAudioMetadata.mjs"; import "./tests/ExtractEmailAddresses.mjs"; +import "./tests/ExtractHashes.mjs"; +import "./tests/ExtractIPAddresses.mjs"; +import "./tests/Fernet.mjs"; +import "./tests/FileTree.mjs"; +import "./tests/FlaskSession.mjs"; +import "./tests/FletcherChecksum.mjs"; +import "./tests/Float.mjs"; import "./tests/Fork.mjs"; import "./tests/FromDecimal.mjs"; -import "./tests/FromGeohash.mjs"; +import "./tests/GOST.mjs"; +import "./tests/GenerateAllChecksums.mjs"; +import "./tests/GenerateAllHashes.mjs"; +import "./tests/GenerateDeBruijnSequence.mjs"; +import "./tests/GenerateQRCode.mjs"; import "./tests/GetAllCasings.mjs"; import "./tests/Gunzip.mjs"; import "./tests/Gzip.mjs"; import "./tests/HASSH.mjs"; +import "./tests/HKDF.mjs"; import "./tests/Hash.mjs"; import "./tests/HaversineDistance.mjs"; import "./tests/Hex.mjs"; import "./tests/Hexdump.mjs"; +import "./tests/IPv6Transition.mjs"; import "./tests/Image.mjs"; import "./tests/IndexOfCoincidence.mjs"; import "./tests/JA3Fingerprint.mjs"; import "./tests/JA3SFingerprint.mjs"; +import "./tests/JA4.mjs"; import "./tests/JSONBeautify.mjs"; import "./tests/JSONMinify.mjs"; import "./tests/JSONtoCSV.mjs"; +import "./tests/JSONtoYAML.mjs"; +import "./tests/JWK.mjs"; import "./tests/JWTDecode.mjs"; import "./tests/JWTSign.mjs"; import "./tests/JWTVerify.mjs"; +import "./tests/Jq.mjs"; +import "./tests/Jsonata.mjs"; import "./tests/Jump.mjs"; import "./tests/LS47.mjs"; +import "./tests/LZNT1Decompress.mjs"; import "./tests/LZString.mjs"; +import "./tests/LevenshteinDistance.mjs"; import "./tests/Lorenz.mjs"; import "./tests/LuhnChecksum.mjs"; +import "./tests/MIMEDecoding.mjs"; import "./tests/MS.mjs"; import "./tests/Magic.mjs"; import "./tests/Media.mjs"; +import "./tests/Modhex.mjs"; import "./tests/MorseCode.mjs"; import "./tests/MultipleBombe.mjs"; +import "./tests/MurmurHash3.mjs"; +import "./tests/NTLM.mjs"; import "./tests/NetBIOS.mjs"; import "./tests/NormaliseUnicode.mjs"; import "./tests/OTP.mjs"; import "./tests/PEMtoHex.mjs"; import "./tests/PGP.mjs"; import "./tests/PHP.mjs"; +import "./tests/PHPSerialize.mjs"; +import "./tests/ParityBit.mjs"; +import "./tests/ParseCSR.mjs"; +import "./tests/ParseEthernetFrame.mjs"; import "./tests/ParseIPRange.mjs"; import "./tests/ParseObjectIDTimestamp.mjs"; import "./tests/ParseQRCode.mjs"; import "./tests/ParseSSHHostKey.mjs"; import "./tests/ParseTCP.mjs"; +import "./tests/ParseTLSRecord.mjs"; import "./tests/ParseTLV.mjs"; import "./tests/ParseUDP.mjs"; +import "./tests/ParseX509CRL.mjs"; import "./tests/PowerSet.mjs"; import "./tests/Protobuf.mjs"; +import "./tests/PubKeyFromCert.mjs"; +import "./tests/PubKeyFromPrivKey.mjs"; +import "./tests/RAKE.mjs"; +import "./tests/RC6.mjs"; import "./tests/RSA.mjs"; +import "./tests/Rabbit.mjs"; import "./tests/Regex.mjs"; import "./tests/Register.mjs"; +import "./tests/RegularExpression.mjs"; +import "./tests/RenderMarkdown.mjs"; +import "./tests/RisonEncodeDecode.mjs"; import "./tests/Rotate.mjs"; import "./tests/SIGABA.mjs"; +import "./tests/SM2.mjs"; import "./tests/SM4.mjs"; +import "./tests/SQLBeautify.mjs"; +import "./tests/Salsa20.mjs"; import "./tests/SeqUtils.mjs"; import "./tests/SetDifference.mjs"; import "./tests/SetIntersection.mjs"; import "./tests/SetUnion.mjs"; +import "./tests/Shuffle.mjs"; import "./tests/SplitColourChannels.mjs"; import "./tests/StrUtils.mjs"; +import "./tests/StripIPv4Header.mjs"; +import "./tests/StripTCPHeader.mjs"; +import "./tests/StripUDPHeader.mjs"; import "./tests/Subsection.mjs"; +import "./tests/SwapCase.mjs"; import "./tests/SymmetricDifference.mjs"; +import "./tests/TakeNthBytes.mjs"; +import "./tests/Template.mjs"; import "./tests/TextEncodingBruteForce.mjs"; +import "./tests/TextIntegerConverter.mjs"; import "./tests/ToFromInsensitiveRegex.mjs"; -import "./tests/ToGeohash.mjs"; import "./tests/TranslateDateTimeFormat.mjs"; import "./tests/Typex.mjs"; +import "./tests/URLEncodeDecode.mjs"; +import "./tests/UnescapeString.mjs"; import "./tests/Unicode.mjs"; +import "./tests/XORChecksum.mjs"; +import "./tests/XSalsa20.mjs"; +import "./tests/XXTEA.mjs"; import "./tests/YARA.mjs"; // Cannot test operations that use the File type yet diff --git a/tests/operations/tests/A1Z26CipherDecode.mjs b/tests/operations/tests/A1Z26CipherDecode.mjs new file mode 100644 index 00000000..97020e0b --- /dev/null +++ b/tests/operations/tests/A1Z26CipherDecode.mjs @@ -0,0 +1,33 @@ +/** + * A1Z26 Cipher Decode tests + * + * @author brick-pixel + * @copyright Crown Copyright 2026 + * @license Apache-2.0 + */ +import TestRegister from "../../lib/TestRegister.mjs"; + +TestRegister.addTests([ + { + "name": "A1Z26 Cipher Decode: basic decode", + "input": "8 5 12 12 15", + "expectedOutput": "hello", + "recipeConfig": [ + { + "op": "A1Z26 Cipher Decode", + "args": ["Space"] + } + ] + }, + { + "name": "A1Z26 Cipher Decode: empty input returns empty string", + "input": "", + "expectedOutput": "", + "recipeConfig": [ + { + "op": "A1Z26 Cipher Decode", + "args": ["Space"] + } + ] + } +]); diff --git a/tests/operations/tests/AESKeyWrap.mjs b/tests/operations/tests/AESKeyWrap.mjs new file mode 100644 index 00000000..bca36a40 --- /dev/null +++ b/tests/operations/tests/AESKeyWrap.mjs @@ -0,0 +1,324 @@ +/** + * @author mikecat + * @copyright Crown Copyright 2022 + * @license Apache-2.0 + */ +import TestRegister from "../../lib/TestRegister.mjs"; + +TestRegister.addTests([ + { + "name": "AES Key Wrap: RFC Test Vector, 128-bit data, 128-bit KEK", + "input": "00112233445566778899aabbccddeeff", + "expectedOutput": "1fa68b0a8112b447aef34bd8fb5a7b829d3e862371d2cfe5", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: RFC Test Vector, 128-bit data, 192-bit KEK", + "input": "00112233445566778899aabbccddeeff", + "expectedOutput": "96778b25ae6ca435f92b5b97c050aed2468ab8a17ad84e5d", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f1011121314151617"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: RFC Test Vector, 128-bit data, 256-bit KEK", + "input": "00112233445566778899aabbccddeeff", + "expectedOutput": "64e8c3f9ce0f5ba263e9777905818a2a93c8191e7d6e8ae7", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: RFC Test Vector, 192-bit data, 192-bit KEK", + "input": "00112233445566778899aabbccddeeff0001020304050607", + "expectedOutput": "031d33264e15d33268f24ec260743edce1c6c7ddee725a936ba814915c6762d2", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f1011121314151617"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: RFC Test Vector, 192-bit data, 256-bit KEK", + "input": "00112233445566778899aabbccddeeff0001020304050607", + "expectedOutput": "a8f9bc1612c68b3ff6e6f4fbe30e71e4769c8b80a32cb8958cd5d17d6b254da1", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: RFC Test Vector, 256-bit data, 256-bit KEK", + "input": "00112233445566778899aabbccddeeff000102030405060708090a0b0c0d0e0f", + "expectedOutput": "28c9f404c4b810f4cbccb35cfb87f8263f5786e2d80ed326cbc7f0e71a99f43bfb988b9b7a02dd21", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: RFC Test Vector, 128-bit data, 128-bit KEK", + "input": "1fa68b0a8112b447aef34bd8fb5a7b829d3e862371d2cfe5", + "expectedOutput": "00112233445566778899aabbccddeeff", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: RFC Test Vector, 128-bit data, 192-bit KEK", + "input": "96778b25ae6ca435f92b5b97c050aed2468ab8a17ad84e5d", + "expectedOutput": "00112233445566778899aabbccddeeff", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f1011121314151617"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: RFC Test Vector, 128-bit data, 256-bit KEK", + "input": "64e8c3f9ce0f5ba263e9777905818a2a93c8191e7d6e8ae7", + "expectedOutput": "00112233445566778899aabbccddeeff", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: RFC Test Vector, 192-bit data, 192-bit KEK", + "input": "031d33264e15d33268f24ec260743edce1c6c7ddee725a936ba814915c6762d2", + "expectedOutput": "00112233445566778899aabbccddeeff0001020304050607", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f1011121314151617"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: RFC Test Vector, 192-bit data, 256-bit KEK", + "input": "a8f9bc1612c68b3ff6e6f4fbe30e71e4769c8b80a32cb8958cd5d17d6b254da1", + "expectedOutput": "00112233445566778899aabbccddeeff0001020304050607", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: RFC Test Vector, 256-bit data, 256-bit KEK", + "input": "28c9f404c4b810f4cbccb35cfb87f8263f5786e2d80ed326cbc7f0e71a99f43bfb988b9b7a02dd21", + "expectedOutput": "00112233445566778899aabbccddeeff000102030405060708090a0b0c0d0e0f", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: invalid KEK length", + "input": "00112233445566778899aabbccddeeff", + "expectedOutput": "KEK must be either 16, 24, or 32 bytes (currently 10 bytes)", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "00010203040506070809"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: invalid IV length", + "input": "00112233445566778899aabbccddeeff", + "expectedOutput": "IV must be 8 bytes (currently 6 bytes)", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: input length not multiple of 8", + "input": "00112233445566778899aabbccddeeff0102", + "expectedOutput": "input must be 8n (n>=2) bytes (currently 18 bytes)", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Wrap: input too short", + "input": "0011223344556677", + "expectedOutput": "input must be 8n (n>=2) bytes (currently 8 bytes)", + "recipeConfig": [ + { + "op": "AES Key Wrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: invalid KEK length", + "input": "1fa68b0a8112b447aef34bd8fb5a7b829d3e862371d2cfe5", + "expectedOutput": "KEK must be either 16, 24, or 32 bytes (currently 10 bytes)", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "00010203040506070809"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: invalid IV length", + "input": "1fa68b0a8112b447aef34bd8fb5a7b829d3e862371d2cfe5", + "expectedOutput": "IV must be 8 bytes (currently 6 bytes)", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: input length not multiple of 8", + "input": "1fa68b0a8112b447aef34bd8fb5a7b829d3e862371d2cfe5e621", + "expectedOutput": "input must be 8n (n>=3) bytes (currently 26 bytes)", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: input too short", + "input": "1fa68b0a8112b447aef34bd8fb5a7b82", + "expectedOutput": "input must be 8n (n>=3) bytes (currently 16 bytes)", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, + { + "name": "AES Key Unwrap: corrupted input", + "input": "1fa68b0a8112b447aef34bd8fb5a7b829d3e862371d2cfe6", + "expectedOutput": "IV mismatch", + "recipeConfig": [ + { + "op": "AES Key Unwrap", + "args": [ + {"option": "Hex", "string": "000102030405060708090a0b0c0d0e0f"}, + {"option": "Hex", "string": "a6a6a6a6a6a6a6a6"}, + "Hex", "Hex" + ], + }, + ], + }, +]); diff --git a/tests/operations/tests/AlternatingCaps.mjs b/tests/operations/tests/AlternatingCaps.mjs new file mode 100644 index 00000000..b23768eb --- /dev/null +++ b/tests/operations/tests/AlternatingCaps.mjs @@ -0,0 +1,19 @@ +/* @author sw5678 + * @copyright Crown Copyright 2024 + * @license Apache-2.0 + */ +import TestRegister from "../../lib/TestRegister.mjs"; + +TestRegister.addTests([ + { + "name": "AlternatingCaps: Basic Example", + "input": "Hello, world!", + "expectedOutput": "hElLo, WoRlD!", + "recipeConfig": [ + { + "op": "Alternating Caps", + "args": [] + }, + ], + } +]); diff --git a/tests/operations/tests/AnalyseUUID.mjs b/tests/operations/tests/AnalyseUUID.mjs new file mode 100644 index 00000000..89118421 --- /dev/null +++ b/tests/operations/tests/AnalyseUUID.mjs @@ -0,0 +1,66 @@ +/** + * Analyse UUID tests + * + * @author ko80240 [csk.dev@proton.me] + * @copyright Crown Copyright 2023 + * @license Apache-2.0 + */ +import TestRegister from "../../lib/TestRegister.mjs"; + +TestRegister.addTests([ + { + "name": "Analyse UUID: v1 UUID extracts timestamp, clock, and node", + "input": "cefa1760-28ee-11f1-9f95-1fb76af3e239", + "expectedOutput": "Version:\n1\n\nTimestamp:\n1774514156502\n\nTimestamp (ISO):\n2026-03-26T08:35:56.502Z\n\nNode:\n1F:B7:6A:F3:E2:39\n\nClock:\n8085\n\nUUID Integer:\n275119515460318071558429785403790975545", + "recipeConfig": [ + { + "op": "Analyse UUID", + "args": [true] + } + ] + }, + { + "name": "Analyse UUID: v7 UUID extracts timestamp, randA, and randB", + "input": "019d294a-af64-7728-9524-26da08f50708", + "expectedOutput": "Version:\n7\n\nTimestamp:\n1774514253668\n\nTimestamp (ISO):\n2026-03-26T08:37:33.668Z\n\nRand A:\n1832\n\nRand B:\n952426DA08F50708\n\nUUID Integer:\n2145256098533991595556290452700595976", + "recipeConfig": [ + { + "op": "Analyse UUID", + "args": [true] + } + ] + }, + { + "name": "Analyse UUID: v4 UUID should show no metadata - not possible", + "input": "f47ac10b-58cc-4372-a567-0e02b2c3d479", + "expectedOutput": "Version:\n4\n\nNo metadata available. Only versions 1, 6, 7 are supported.\n\nUUID Integer:\n324969006592305634633390616021200786553", + "recipeConfig": [ + { + "op": "Analyse UUID", + "args": [true] + } + ] + }, + { + "name": "Analyse UUID: if the 'Include Metadata' option is false it should return not metadata", + "input": "cefa1760-28ee-11f1-9f95-1fb76af3e239", + "expectedOutput": "Version:\n1\n\nUUID Integer:\n275119515460318071558429785403790975545", + "recipeConfig": [ + { + "op": "Analyse UUID", + "args": [false] + } + ] + }, + { + "name": "Analyse UUID: invalid UUID should return error message", + "input": "not-a-uuid", + "expectedOutput": "Invalid UUID", + "recipeConfig": [ + { + "op": "Analyse UUID", + "args": [true] + } + ] + } +]); diff --git a/tests/operations/tests/BLAKE3.mjs b/tests/operations/tests/BLAKE3.mjs new file mode 100644 index 00000000..42cb4dc1 --- /dev/null +++ b/tests/operations/tests/BLAKE3.mjs @@ -0,0 +1,55 @@ +/** + * BLAKE3 tests. + * @author xumptex [xumptex@outlook.fr] + * @copyright Crown Copyright 2025 + * @license Apache-2.0 + */ +import TestRegister from "../../lib/TestRegister.mjs"; + +TestRegister.addTests([ + { + name: "BLAKE3: 8 - Hello world", + input: "Hello world", + expectedOutput: "e7e6fb7d2869d109", + recipeConfig: [ + { "op": "BLAKE3", + "args": [8, ""] } + ] + }, + { + name: "BLAKE3: 16 - Hello world 2", + input: "Hello world 2", + expectedOutput: "2a3df5fe5f0d3fcdd995fc203c7f7c52", + recipeConfig: [ + { "op": "BLAKE3", + "args": [16, ""] } + ] + }, + { + name: "BLAKE3: 32 - Hello world", + input: "Hello world", + expectedOutput: "e7e6fb7d2869d109b62cdb1227208d4016cdaa0af6603d95223c6a698137d945", + recipeConfig: [ + { "op": "BLAKE3", + "args": [32, ""] } + ] + }, + { + name: "BLAKE3: Key Test", + input: "Hello world", + expectedOutput: "59dd23ac9d025690", + recipeConfig: [ + { "op": "BLAKE3", + "args": [8, "ThiskeyisexactlythirtytwoBytesLo"] } + ] + }, + { + name: "BLAKE3: Key Test 2", + input: "Hello world", + expectedOutput: "c8302c9634c1da42", + recipeConfig: [ + { "op": "BLAKE3", + "args": [8, "ThiskeyisexactlythirtytwoByteslo"] } + ] + } +]); diff --git a/tests/operations/tests/Base32.mjs b/tests/operations/tests/Base32.mjs new file mode 100644 index 00000000..760cdf14 --- /dev/null +++ b/tests/operations/tests/Base32.mjs @@ -0,0 +1,176 @@ +/** + * Base32 Tests + * + * @author Peter C-S [petercs@purelymail.com] + * @license Apache-2.0 + */ + +import TestRegister from "../../lib/TestRegister.mjs"; +import {ALPHABET_OPTIONS} from "../../../src/core/lib/Base32.mjs"; + +// Example Standard Base32 Tests +const STANDARD_INP = "HELLO BASE32"; +const STANDARD_OUT = "JBCUYTCPEBBECU2FGMZA===="; + +// Example Hex Extended Base32 Tests +const EXTENDED_INP = "HELLO BASE32 EXTENDED"; +const EXTENDED_OUT = "912KOJ2F41142KQ56CP20HAOAH2KSH258G======"; + +// All Bytes +const ALL_BYTES = [ + "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", + "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", + "\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f", + "\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f", + "\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f", + "\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f", + "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f", + "\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f", + "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f", + "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f", + "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf", + "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf", + "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf", + "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf", + "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef", + "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff", +].join(""); + +const ALL_BYTES_EXTENDED_OUT = "000G40O40K30E209185GO38E1S8124GJ2GAHC5OO34D1M70T3OFI08924CI2A9H750KIKAPC5KN2UC1H68PJ8D9M6SS3IEHR7GUJSFQ085146H258P3KGIAA9D64QJIFA18L4KQKALB5EM2PB9DLONAUBTG62OJ3CHIMCPR8D5L6MR3DDPNN0SBIEDQ7ATJNF1SNKURSFLV7V041GA1O91C6GU48J2KBHI6OT3SGI699754LIQBPH6CQJEE9R7KVK2GQ58T4KMJAFA59LALQPBDELUOB3CLJMIQRDDTON6TBNF5TNQVS1GE2OF2CBHM7P34SLIUCPN7CVK6HQB9T9LEMQVCDJMMRRJETTNV0S7HE7P75SRJUHQFATFMERRNFU3OV5SVKUNRFFU7PVBTVPVFUVS======"; +const ALL_BYTES_STANDARD_OUT = "AAAQEAYEAUDAOCAJBIFQYDIOB4IBCEQTCQKRMFYYDENBWHA5DYPSAIJCEMSCKJRHFAUSUKZMFUXC6MBRGIZTINJWG44DSOR3HQ6T4P2AIFBEGRCFIZDUQSKKJNGE2TSPKBIVEU2UKVLFOWCZLJNVYXK6L5QGCYTDMRSWMZ3INFVGW3DNNZXXA4LSON2HK5TXPB4XU634PV7H7AEBQKBYJBMGQ6EITCULRSGY5D4QSGJJHFEVS2LZRGM2TOOJ3HU7UCQ2FI5EUWTKPKFJVKV2ZLNOV6YLDMVTWS23NN5YXG5LXPF5X274BQOCYPCMLRWHZDE4VS6MZXHM7UGR2LJ5JVOW27MNTWW33TO55X7A4HROHZHF43T6R2PK5PWO33XP6DY7F47U6X3PP6HZ7L57Z7P674======"; + +TestRegister.addTests([ + { + name: "To Base32 Standard: nothing", + input: "", + expectedOutput: "", + recipeConfig: [ + { + op: "To Base32", + args: [ALPHABET_OPTIONS[0].value], + }, + ], + }, + { + name: "To Base32 Hex Extended: nothing", + input: "", + expectedOutput: "", + recipeConfig: [ + { + op: "To Base32", + args: [ALPHABET_OPTIONS[1].value], + }, + ], + }, + { + name: "From Base32 Standard: nothing", + input: "", + expectedOutput: "", + recipeConfig: [ + { + op: "From Base32", + args: [ALPHABET_OPTIONS[0].value, false], + }, + ], + }, + { + name: "From Base32 Hex Extended: nothing", + input: "", + expectedOutput: "", + recipeConfig: [ + { + op: "From Base32", + args: [ALPHABET_OPTIONS[1].value, false], + }, + ], + }, + { + name: "To Base32 Standard: " + STANDARD_INP, + input: STANDARD_INP, + expectedOutput: STANDARD_OUT, + recipeConfig: [ + { + op: "To Base32", + args: [ALPHABET_OPTIONS[0].value], + }, + ], + }, + { + name: "To Base32 Hex Extended: " + EXTENDED_INP, + input: EXTENDED_INP, + expectedOutput: EXTENDED_OUT, + recipeConfig: [ + { + op: "To Base32", + args: [ALPHABET_OPTIONS[1].value], + }, + ], + }, + { + name: "From Base32 Standard: " + STANDARD_OUT, + input: STANDARD_OUT, + expectedOutput: STANDARD_INP, + recipeConfig: [ + { + op: "From Base32", + args: [ALPHABET_OPTIONS[0].value, false], + }, + ], + }, + { + name: "From Base32 Hex Extended: " + EXTENDED_OUT, + input: EXTENDED_OUT, + expectedOutput: EXTENDED_INP, + recipeConfig: [ + { + op: "From Base32", + args: [ALPHABET_OPTIONS[1].value, false], + }, + ], + }, + { + name: "To Base32 Hex Standard: All Bytes", + input: ALL_BYTES, + expectedOutput: ALL_BYTES_STANDARD_OUT, + recipeConfig: [ + { + op: "To Base32", + args: [ALPHABET_OPTIONS[0].value], + }, + ], + }, + { + name: "To Base32 Hex Extended: All Bytes", + input: ALL_BYTES, + expectedOutput: ALL_BYTES_EXTENDED_OUT, + recipeConfig: [ + { + op: "To Base32", + args: [ALPHABET_OPTIONS[1].value], + }, + ], + }, + { + name: "From Base32 Hex Standard: All Bytes", + input: ALL_BYTES_STANDARD_OUT, + expectedOutput: ALL_BYTES, + recipeConfig: [ + { + op: "From Base32", + args: [ALPHABET_OPTIONS[0].value, false], + }, + ], + }, + { + name: "From Base32 Hex Extended: All Bytes", + input: ALL_BYTES_EXTENDED_OUT, + expectedOutput: ALL_BYTES, + recipeConfig: [ + { + op: "From Base32", + args: [ALPHABET_OPTIONS[1].value, false], + }, + ], + }, +]); + diff --git a/tests/operations/tests/Base58.mjs b/tests/operations/tests/Base58.mjs index c23ba9ab..8090b84b 100644 --- a/tests/operations/tests/Base58.mjs +++ b/tests/operations/tests/Base58.mjs @@ -53,6 +53,28 @@ TestRegister.addTests([ }, ], }, + { + name: "To Base58 all null", + input: "\0\0\0\0\0\0", + expectedOutput: "111111", + recipeConfig: [ + { + op: "To Base58", + args: ["123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"], + }, + ], + }, + { + name: "From Base58 all null", + input: "111111", + expectedOutput: "\0\0\0\0\0\0", + recipeConfig: [ + { + op: "From Base58", + args: ["123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"], + }, + ], + }, { name: "To Base58 with null prefix and suffix", input: "\0\0\0Hello\0\0\0", diff --git a/tests/operations/tests/Base85.mjs b/tests/operations/tests/Base85.mjs index 8e1d0a23..44e12ee2 100644 --- a/tests/operations/tests/Base85.mjs +++ b/tests/operations/tests/Base85.mjs @@ -16,6 +16,10 @@ DIb:@FD,*)+C]U=@3BN#EcYf8ATD3s@q?d$AftVqCh[NqF