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"; @@ -33,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, + }, ]; } @@ -131,41 +133,60 @@ class AddTextToImage extends Operation { } 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; @@ -175,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, + }); } } @@ -210,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; } @@ -222,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})`); } } @@ -261,7 +314,6 @@ class AddTextToImage extends Operation { return `
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"; @@ -35,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"], + }, ]; } @@ -73,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) { @@ -106,7 +105,6 @@ class BlurImage 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"; @@ -32,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, + }, ]; } @@ -76,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]; @@ -103,18 +91,25 @@ class ConvertImageFormat extends Operation { 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})`); } @@ -137,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"; @@ -34,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 (%)", @@ -65,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, + }, ]; } @@ -92,7 +92,17 @@ 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."); } @@ -108,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) { @@ -145,7 +160,6 @@ class CropImage extends Operation { return `
Bech32m (BIP-0350) is an updated version used for Bitcoin Taproot addresses.
Auto-detect will attempt Bech32 first, then Bech32m if the checksum fails.
Output format options allow you to see the Human-Readable Part (HRP) along with the decoded data."; + this.infoURL = "https://wikipedia.org/wiki/Bech32"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Encoding", + "type": "option", + "value": ["Auto-detect", "Bech32", "Bech32m"] + }, + { + "name": "Output Format", + "type": "option", + "value": ["Raw", "Hex", "Bitcoin scriptPubKey", "HRP: Hex", "JSON"] + } + ]; + this.checks = [ + { + // Bitcoin mainnet SegWit/Taproot addresses + pattern: "^bc1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{6,87}$", + flags: "i", + args: ["Auto-detect", "Hex"] + }, + { + // Bitcoin testnet addresses + pattern: "^tb1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{6,87}$", + flags: "i", + args: ["Auto-detect", "Hex"] + }, + { + // AGE public keys + pattern: "^age1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{6,87}$", + flags: "i", + args: ["Auto-detect", "HRP: Hex"] + }, + { + // AGE secret keys + pattern: "^AGE-SECRET-KEY-1[QPZRY9X8GF2TVDW0S3JN54KHCE6MUA7L]{6,87}$", + flags: "", + args: ["Auto-detect", "HRP: Hex"] + }, + { + // Litecoin mainnet addresses + pattern: "^ltc1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{6,87}$", + flags: "i", + args: ["Auto-detect", "Hex"] + }, + { + // Generic bech32 pattern + pattern: "^[a-z]{1,83}1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{6,}$", + flags: "i", + args: ["Auto-detect", "Hex"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const encoding = args[0]; + const outputFormat = args[1]; + + input = input.trim(); + + if (input.length === 0) { + return ""; + } + + const decoded = decode(input, encoding); + + // Format output based on selected option + switch (outputFormat) { + case "Raw": + return decoded.data.map(b => String.fromCharCode(b)).join(""); + + case "Hex": + return toHex(decoded.data, ""); + + case "Bitcoin scriptPubKey": { + // Convert to Bitcoin scriptPubKey format as shown in BIP-0173/BIP-0350 + // Format: [OP_version][length][witness_program] + // OP_0 = 0x00, OP_1-OP_16 = 0x51-0x60 + if (decoded.witnessVersion === null || decoded.data.length < 2) { + // Not a SegWit address, fall back to hex + return toHex(decoded.data, ""); + } + const witnessVersion = decoded.data[0]; + const witnessProgram = decoded.data.slice(1); + + // Convert witness version to OP code + let opCode; + if (witnessVersion === 0) { + opCode = 0x00; // OP_0 + } else if (witnessVersion >= 1 && witnessVersion <= 16) { + opCode = 0x50 + witnessVersion; // OP_1 = 0x51, ..., OP_16 = 0x60 + } else { + // Invalid witness version, fall back to hex + return toHex(decoded.data, ""); + } + + // Build scriptPubKey: [OP_version][length][program] + const scriptPubKey = [opCode, witnessProgram.length, ...witnessProgram]; + return toHex(scriptPubKey, ""); + } + + case "HRP: Hex": + return `${decoded.hrp}: ${toHex(decoded.data, "")}`; + + case "JSON": + return JSON.stringify({ + hrp: decoded.hrp, + encoding: decoded.encoding, + data: toHex(decoded.data, "") + }, null, 2); + + default: + return toHex(decoded.data, ""); + } + } + +} + +export default FromBech32; diff --git a/src/core/operations/FromHexdump.mjs b/src/core/operations/FromHexdump.mjs index e8c25441..6fd3c1dc 100644 --- a/src/core/operations/FromHexdump.mjs +++ b/src/core/operations/FromHexdump.mjs @@ -43,7 +43,7 @@ class FromHexdump extends Operation { */ run(input, args) { const output = [], - regex = /^\s*(?:[\dA-F]{4,16}h?:?)?[ \t]+((?:[\dA-F]{2} ){1,8}(?:[ \t]|[\dA-F]{2}-)(?:[\dA-F]{2} ){1,8}|(?:[\dA-F]{4} )*[\dA-F]{4}|(?:[\dA-F]{2} )*[\dA-F]{2})/igm; + regex = /^\s*(?:[\dA-F]{4,16}h?:?)?[ \t]+((?:[\dA-F]{2} ){1,8}(?:[ \t]|[\dA-F]{2}-)(?:[\dA-F]{2} ){1,8}|(?:[\dA-F]{4} )+(?:[\dA-F]{2})?|(?:[\dA-F]{2} )*[\dA-F]{2})/igm; let block, line; while ((block = regex.exec(input))) { diff --git a/src/core/operations/FromQuotedPrintable.mjs b/src/core/operations/FromQuotedPrintable.mjs index 7dce45b6..4854c150 100644 --- a/src/core/operations/FromQuotedPrintable.mjs +++ b/src/core/operations/FromQuotedPrintable.mjs @@ -23,7 +23,7 @@ class FromQuotedPrintable extends Operation { this.name = "From Quoted Printable"; this.module = "Default"; - this.description = "Converts QP-encoded text back to standard text.
e.g. The quoted-printable encoded string
hello=20world becomes hello world";
+ this.description = "Converts QP-encoded text back to standard text. This format is a content transfer encoding common in email messages.e.g. The quoted-printable encoded string
hello=20world becomes hello world";
this.infoURL = "https://wikipedia.org/wiki/Quoted-printable";
this.inputType = "string";
this.outputType = "byteArray";
diff --git a/src/core/operations/GenerateImage.mjs b/src/core/operations/GenerateImage.mjs
index 118e3a32..053e4ba1 100644
--- a/src/core/operations/GenerateImage.mjs
+++ b/src/core/operations/GenerateImage.mjs
@@ -7,16 +7,15 @@
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
import Utils from "../Utils.mjs";
-import {isImage} from "../lib/FileType.mjs";
-import {toBase64} from "../lib/Base64.mjs";
-import {isWorkerEnvironment} from "../Utils.mjs";
-import Jimp from "jimp/es/index.js";
+import { isImage } from "../lib/FileType.mjs";
+import { toBase64 } from "../lib/Base64.mjs";
+import { isWorkerEnvironment } from "../Utils.mjs";
+import { Jimp, JimpMime, ResizeStrategy, rgbaToInt } from "jimp";
/**
* Generate Image operation
*/
class GenerateImage extends Operation {
-
/**
* GenerateImage constructor
*/
@@ -25,27 +24,28 @@ class GenerateImage extends Operation {
this.name = "Generate Image";
this.module = "Image";
- this.description = "Generates an image using the input as pixel values.";
+ this.description =
+ "Generates an image using the input as pixel values.";
this.infoURL = "";
this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer";
this.presentType = "html";
this.args = [
{
- "name": "Mode",
- "type": "option",
- "value": ["Greyscale", "RG", "RGB", "RGBA", "Bits"]
+ name: "Mode",
+ type: "option",
+ value: ["Greyscale", "RG", "RGB", "RGBA", "Bits"],
},
{
- "name": "Pixel Scale Factor",
- "type": "number",
- "value": 8,
+ name: "Pixel Scale Factor",
+ type: "number",
+ value: 8,
},
{
- "name": "Pixels per row",
- "type": "number",
- "value": 64,
- }
+ name: "Pixels per row",
+ type: "number",
+ value: 64,
+ },
];
}
@@ -67,21 +67,23 @@ class GenerateImage extends Operation {
}
const bytePerPixelMap = {
- "Greyscale": 1,
- "RG": 2,
- "RGB": 3,
- "RGBA": 4,
- "Bits": 1/8,
+ Greyscale: 1,
+ RG: 2,
+ RGB: 3,
+ RGBA: 4,
+ Bits: 1 / 8,
};
const bytesPerPixel = bytePerPixelMap[mode];
- if (bytesPerPixel > 0 && input.length % bytesPerPixel !== 0) {
- throw new OperationError(`Number of bytes is not a divisor of ${bytesPerPixel}`);
+ if (bytesPerPixel > 0 && input.length % bytesPerPixel !== 0) {
+ throw new OperationError(
+ `Number of bytes is not a divisor of ${bytesPerPixel}`,
+ );
}
const height = Math.ceil(input.length / bytesPerPixel / width);
- const image = await new Jimp(width, height, (err, image) => {});
+ const image = new Jimp({ width, height });
if (isWorkerEnvironment())
self.sendStatusMessage("Generating image from data...");
@@ -94,8 +96,8 @@ class GenerateImage extends Operation {
const x = index % width;
const y = Math.floor(index / width);
- const value = curByte[k] === "0" ? 0xFF : 0x00;
- const pixel = Jimp.rgbaToInt(value, value, value, 0xFF);
+ const value = curByte[k] === "0" ? 0xff : 0x00;
+ const pixel = rgbaToInt(value, value, value, 0xff);
image.setPixelColor(pixel, x, y);
}
}
@@ -109,7 +111,7 @@ class GenerateImage extends Operation {
let red = 0x00;
let green = 0x00;
let blue = 0x00;
- let alpha = 0xFF;
+ let alpha = 0xff;
switch (mode) {
case "Greyscale":
@@ -139,10 +141,12 @@ class GenerateImage extends Operation {
}
try {
- const pixel = Jimp.rgbaToInt(red, green, blue, alpha);
+ const pixel = rgbaToInt(red, green, blue, alpha);
image.setPixelColor(pixel, x, y);
} catch (err) {
- throw new OperationError(`Error while generating image from pixel values. (${err})`);
+ throw new OperationError(
+ `Error while generating image from pixel values. (${err})`,
+ );
}
}
}
@@ -151,11 +155,15 @@ class GenerateImage extends Operation {
if (isWorkerEnvironment())
self.sendStatusMessage("Scaling image...");
- image.scaleToFit(width*scale, height*scale, Jimp.RESIZE_NEAREST_NEIGHBOR);
+ image.scaleToFit({
+ w: width * scale,
+ h: height * scale,
+ mode: ResizeStrategy.NEAREST_NEIGHBOR,
+ });
}
try {
- const imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
+ const imageBuffer = await image.getBuffer(JimpMime.png);
return imageBuffer.buffer;
} catch (err) {
throw new OperationError(`Error generating image. (${err})`);
@@ -178,7 +186,6 @@ class GenerateImage extends Operation {
return `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/PseudoRandomIntegerGenerator.mjs b/src/core/operations/PseudoRandomIntegerGenerator.mjs new file mode 100644 index 00000000..a2d83a92 --- /dev/null +++ b/src/core/operations/PseudoRandomIntegerGenerator.mjs @@ -0,0 +1,164 @@ +/** + * @author cktgh [chankaitung@gmail.com] + * @copyright Crown Copyright 2026 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import OperationError from "../errors/OperationError.mjs"; +import forge from "node-forge"; +import Utils, { isWorkerEnvironment } from "../Utils.mjs"; +import { DELIM_OPTIONS } from "../lib/Delim.mjs"; + +/** + * Pseudo-Random Integer Generator operation + */ +class PseudoRandomIntegerGenerator extends Operation { + + // in theory 2**53 is the max range, but we use Number.MAX_SAFE_INTEGER (2**53 - 1) as it is more consistent. + static MAX_RANGE = Number.MAX_SAFE_INTEGER; + // arbitrary choice + static BUFFER_SIZE = 1024; + + /** + * PseudoRandomIntegerGenerator constructor + */ + constructor() { + super(); + + this.name = "Pseudo-Random Integer Generator"; + this.module = "Ciphers"; + this.description = "A cryptographically-secure pseudo-random number generator (PRNG).
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/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/RandomizeColourPalette.mjs b/src/core/operations/RandomizeColourPalette.mjs index fa8fa59e..186023c2 100644 --- a/src/core/operations/RandomizeColourPalette.mjs +++ b/src/core/operations/RandomizeColourPalette.mjs @@ -10,13 +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 Jimp from "jimp/es/index.js"; +import { Jimp } from "jimp"; /** * Randomize Colour Palette operation */ class RandomizeColourPalette extends Operation { - /** * RandomizeColourPalette constructor */ @@ -25,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"; @@ -34,8 +34,8 @@ class RandomizeColourPalette extends Operation { { name: "Seed", type: "string", - value: "" - } + value: "", + }, ]; } @@ -45,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)), + 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; } @@ -77,7 +78,6 @@ class RandomizeColourPalette extends Operation { return `
" + + "Text is interpreted as a big-endian sequence of character codes. For example:
" + + "ABC is 0x414243 (hex) is 4276803 (decimal)
" + + "Input format detection:
" + + "Decimal: digits 0-9 only
" + + "Hexadecimal: 0x... prefix
" + + "Quoted or unquoted text: treated as string
" + + "Character limitations:
" + + "Text input may only contain ASCII and Latin-1 characters (code point < 256).
" + + "Multi-byte Unicode characters will generate an error.
." ; + this.infoURL = "https://wikipedia.org/wiki/Endianness"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + name: "Output format", + type: "option", + value: ["String", "Decimal", "Hexadecimal"] + } + ]; + this.name = "Text-Integer Conversion"; + this.module = "Default"; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const outputFormat = args[0]; + const trimmed = input.trim(); + + let bigIntValue; + + if (!trimmed) { + // Null input - treat as zero + bigIntValue = 0; + } else if (/^0x[0-9a-f]+$/i.test(trimmed) || + /^[+-]?[0-9]+$/.test(trimmed)) { + // Hex or decimal integer + bigIntValue = BigInt(trimmed); + } else if (/^["'].*["']$/.test(trimmed)) { + // Quoted string: Remove quotes and convert text to BigInt + const text = trimmed.slice(1, -1); + bigIntValue = textToBigInt(text); + } else { + // Assume it's unquoted text + bigIntValue = textToBigInt(trimmed); + } + + // Convert to output format + if (outputFormat === "String") { + return bigIntToText(bigIntValue); + } else if (outputFormat === "Decimal") { + return bigIntValue.toString(); + } else { // Hexadecimal + return "0x" + bigIntValue.toString(16); + } + } +} + +export default TextIntegerConverter; diff --git a/src/core/operations/ToBase85.mjs b/src/core/operations/ToBase85.mjs index 839ef1e4..e9b0a485 100644 --- a/src/core/operations/ToBase85.mjs +++ b/src/core/operations/ToBase85.mjs @@ -33,7 +33,7 @@ class ToBase85 extends Operation { value: ALPHABET_OPTIONS }, { - name: "Include delimeter", + name: "Include delimiter", type: "boolean", value: false } diff --git a/src/core/operations/ToBech32.mjs b/src/core/operations/ToBech32.mjs new file mode 100644 index 00000000..a7c97355 --- /dev/null +++ b/src/core/operations/ToBech32.mjs @@ -0,0 +1,92 @@ +/** + * @author Medjedtxm + * @copyright Crown Copyright 2025 + * @license Apache-2.0 + */ + +import Operation from "../Operation.mjs"; +import { encode } from "../lib/Bech32.mjs"; +import { fromHex } from "../lib/Hex.mjs"; + +/** + * To Bech32 operation + */ +class ToBech32 extends Operation { + + /** + * ToBech32 constructor + */ + constructor() { + super(); + + this.name = "To Bech32"; + this.module = "Default"; + this.description = "Bech32 is an encoding scheme primarily used for Bitcoin SegWit addresses (BIP-0173). It uses a 32-character alphabet that excludes easily confused characters (1, b, i, o) and includes a checksum for error detection.
Bech32m (BIP-0350) is an updated version that fixes a weakness in the original Bech32 checksum and is used for Bitcoin Taproot addresses.
The Human-Readable Part (HRP) identifies the network or purpose (e.g., 'bc' for Bitcoin mainnet, 'tb' for testnet, 'age' for AGE encryption keys).
Maximum output length is 90 characters as per specification."; + this.infoURL = "https://wikipedia.org/wiki/Bech32"; + this.inputType = "ArrayBuffer"; + this.outputType = "string"; + this.args = [ + { + "name": "Human-Readable Part (HRP)", + "type": "string", + "value": "bc" + }, + { + "name": "Encoding", + "type": "option", + "value": ["Bech32", "Bech32m"] + }, + { + "name": "Input Format", + "type": "option", + "value": ["Raw bytes", "Hex"] + }, + { + "name": "Mode", + "type": "option", + "value": ["Generic", "Bitcoin SegWit"] + }, + { + "name": "Witness Version", + "type": "number", + "value": 0, + "hint": "SegWit witness version (0-16). Only used in Bitcoin SegWit mode." + } + ]; + } + + /** + * @param {ArrayBuffer} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const hrp = args[0]; + const encoding = args[1]; + const inputFormat = args[2]; + const mode = args[3]; + const witnessVersion = args[4]; + + let inputArray; + if (inputFormat === "Hex") { + // Convert hex string to bytes + const hexStr = new TextDecoder().decode(new Uint8Array(input)).replace(/\s/g, ""); + inputArray = fromHex(hexStr); + } else { + inputArray = new Uint8Array(input); + } + + if (mode === "Bitcoin SegWit") { + // Prepend witness version to the input data + const withVersion = new Uint8Array(inputArray.length + 1); + withVersion[0] = witnessVersion; + withVersion.set(inputArray, 1); + return encode(hrp, withVersion, encoding, true); + } + + return encode(hrp, inputArray, encoding, false); + } + +} + +export default ToBech32; diff --git a/src/core/operations/ToQuotedPrintable.mjs b/src/core/operations/ToQuotedPrintable.mjs index 9db5c5a5..2ea204f9 100644 --- a/src/core/operations/ToQuotedPrintable.mjs +++ b/src/core/operations/ToQuotedPrintable.mjs @@ -23,7 +23,7 @@ class ToQuotedPrintable extends Operation { this.name = "To Quoted Printable"; this.module = "Default"; - this.description = "Quoted-Printable, or QP encoding, is an encoding using printable ASCII characters (alphanumeric and the equals sign '=') to transmit 8-bit data over a 7-bit data path or, generally, over a medium which is not 8-bit clean. It is defined as a MIME content transfer encoding for use in e-mail.
QP works by using the equals sign '=' as an escape character. It also limits line length to 76, as some software has limits on line length."; + this.description = "Quoted-Printable, or QP encoding, is an encoding using printable ASCII characters (alphanumeric and the equals sign '=') to transmit 8-bit data over a 7-bit data path or, generally, over a medium which is not 8-bit clean. It is defined as a MIME content transfer encoding for use in email.
QP works by using the equals sign '=' as an escape character. It also limits line length to 76, as some software has limits on line length."; this.infoURL = "https://wikipedia.org/wiki/Quoted-printable"; this.inputType = "ArrayBuffer"; this.outputType = "string"; diff --git a/src/core/operations/UnescapeUnicodeCharacters.mjs b/src/core/operations/UnescapeUnicodeCharacters.mjs index 5bb0e5ac..02d16662 100644 --- a/src/core/operations/UnescapeUnicodeCharacters.mjs +++ b/src/core/operations/UnescapeUnicodeCharacters.mjs @@ -30,6 +30,23 @@ class UnescapeUnicodeCharacters extends Operation { "value": ["\\u", "%u", "U+"] } ]; + this.checks = [ + { + pattern: "\\\\u(?:[\\da-f]{4,6})", + flags: "i", + args: ["\\u"] + }, + { + pattern: "%u(?:[\\da-f]{4,6})", + flags: "i", + args: ["%u"] + }, + { + pattern: "U\\+(?:[\\da-f]{4,6})", + flags: "i", + args: ["U+"] + } + ]; } /** diff --git a/src/core/operations/ViewBitPlane.mjs b/src/core/operations/ViewBitPlane.mjs index 8c93f16c..3740c10d 100644 --- a/src/core/operations/ViewBitPlane.mjs +++ b/src/core/operations/ViewBitPlane.mjs @@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs"; import Utils from "../Utils.mjs"; import { isImage } from "../lib/FileType.mjs"; import { toBase64 } from "../lib/Base64.mjs"; -import Jimp from "jimp/es/index.js"; +import { Jimp } from "jimp"; /** * View Bit Plane operation */ class ViewBitPlane extends Operation { - /** * ViewBitPlane constructor */ @@ -24,7 +23,8 @@ class ViewBitPlane extends Operation { this.name = "View Bit Plane"; this.module = "Image"; - this.description = "Extracts and displays a bit plane of any given image. These show only a single bit from each pixel, and can be used to hide messages in Steganography."; + this.description = + "Extracts and displays a bit plane of any given image. These show only a single bit from each pixel, and can be used to hide messages in Steganography."; this.infoURL = "https://wikipedia.org/wiki/Bit_plane"; this.inputType = "ArrayBuffer"; this.outputType = "ArrayBuffer"; @@ -33,13 +33,13 @@ class ViewBitPlane extends Operation { { name: "Colour", type: "option", - value: COLOUR_OPTIONS + value: COLOUR_OPTIONS, }, { name: "Bit", type: "number", - value: 0 - } + value: 0, + }, ]; } @@ -49,36 +49,38 @@ class ViewBitPlane 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 [colour, bit] = args, parsedImage = await Jimp.read(input), width = parsedImage.bitmap.width, height = parsedImage.bitmap.height, colourIndex = COLOUR_OPTIONS.indexOf(colour), - bitIndex = 7-bit; + bitIndex = 7 - bit; if (bit < 0 || bit > 7) { - throw new OperationError("Error: Bit argument must be between 0 and 7"); + throw new OperationError( + "Error: Bit argument must be between 0 and 7", + ); } let pixel, bin, newPixelValue; - parsedImage.scan(0, 0, width, height, function(x, y, idx) { + parsedImage.scan(0, 0, width, height, function (x, y, idx) { pixel = this.bitmap.data[idx + colourIndex]; bin = Utils.bin(pixel); newPixelValue = 255; if (bin.charAt(bitIndex) === "1") newPixelValue = 0; - for (let i=0; i < 3; i++) { + for (let i = 0; i < 3; i++) { this.bitmap.data[idx + i] = newPixelValue; } this.bitmap.data[idx + 3] = 255; - }); - const imageBuffer = await parsedImage.getBufferAsync(Jimp.AUTO); + const imageBuffer = await parsedImage.getBuffer(parsedImage.mime); return new Uint8Array(imageBuffer).buffer; } @@ -94,14 +96,8 @@ class ViewBitPlane extends Operation { return `
-
+ html += `
+
-
+ html += `
+
`;
break;
case "toggleString":
- html += `
+ html += `
-
+
`;
break;
case "number":
- html += `
-
+ html += `
+
`;
break;
case "boolean":
- html += `
+ html += `
-