mirror of
https://github.com/gchq/CyberChef.git
synced 2025-06-18 04:05:25 -04:00
Merge branch 'master' of github.com:gchq/CyberChef into node-lib
This commit is contained in:
d98762625
commit
5047619e54
289 changed files with 2427 additions and 1991 deletions
|
|
@ -22,6 +22,7 @@ class ADD extends Operation {
|
|||
this.name = "ADD";
|
||||
this.module = "Default";
|
||||
this.description = "ADD the input with the given key (e.g. <code>fe023da5</code>), MOD 255";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Bitwise_operation#Bitwise_operators";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
@ -29,7 +30,7 @@ class ADD extends Operation {
|
|||
"name": "Key",
|
||||
"type": "toggleString",
|
||||
"value": "",
|
||||
"toggleValues": ["Hex", "Base64", "UTF8", "Latin1"]
|
||||
"toggleValues": ["Hex", "Decimal", "Base64", "UTF8", "Latin1"]
|
||||
}
|
||||
];
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ class AESDecrypt extends Operation {
|
|||
this.name = "AES Decrypt";
|
||||
this.module = "Ciphers";
|
||||
this.description = "Advanced Encryption Standard (AES) is a U.S. Federal Information Processing Standard (FIPS). It was selected after a 5-year process where 15 competing designs were evaluated.<br><br><b>Key:</b> The following algorithms will be used based on the size of the key:<ul><li>16 bytes = AES-128</li><li>24 bytes = AES-192</li><li>32 bytes = AES-256</li></ul><br><br><b>IV:</b> The Initialization Vector should be 16 bytes long. If not entered, it will default to 16 null bytes.<br><br><b>Padding:</b> In CBC and ECB mode, PKCS#7 padding will be used.<br><br><b>GCM Tag:</b> This field is ignored unless 'GCM' mode is used.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Advanced_Encryption_Standard";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ class AESEncrypt extends Operation {
|
|||
this.name = "AES Encrypt";
|
||||
this.module = "Ciphers";
|
||||
this.description = "Advanced Encryption Standard (AES) is a U.S. Federal Information Processing Standard (FIPS). It was selected after a 5-year process where 15 competing designs were evaluated.<br><br><b>Key:</b> The following algorithms will be used based on the size of the key:<ul><li>16 bytes = AES-128</li><li>24 bytes = AES-192</li><li>32 bytes = AES-256</li></ul>You can generate a password-based key using one of the KDF operations.<br><br><b>IV:</b> The Initialization Vector should be 16 bytes long. If not entered, it will default to 16 null bytes.<br><br><b>Padding:</b> In CBC and ECB mode, PKCS#7 padding will be used.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Advanced_Encryption_Standard";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class AND extends Operation {
|
|||
this.name = "AND";
|
||||
this.module = "Default";
|
||||
this.description = "AND the input with the given key.<br>e.g. <code>fe023da5</code>";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Bitwise_operation#AND";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
@ -29,7 +30,7 @@ class AND extends Operation {
|
|||
"name": "Key",
|
||||
"type": "toggleString",
|
||||
"value": "",
|
||||
"toggleValues": ["Hex", "Base64", "UTF8", "Latin1"]
|
||||
"toggleValues": ["Hex", "Decimal", "Base64", "UTF8", "Latin1"]
|
||||
}
|
||||
];
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class Adler32Checksum extends Operation {
|
|||
this.name = "Adler-32 Checksum";
|
||||
this.module = "Hashing";
|
||||
this.description = "Adler-32 is a checksum algorithm which was invented by Mark Adler in 1995, and is a modification of the Fletcher checksum. Compared to a cyclic redundancy check of the same length, it trades reliability for speed (preferring the latter).<br><br>Adler-32 is more reliable than Fletcher-16, and slightly less reliable than Fletcher-32.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Adler-32";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class AffineCipherDecode extends Operation {
|
|||
this.name = "Affine Cipher Decode";
|
||||
this.module = "Ciphers";
|
||||
this.description = "The Affine cipher is a type of monoalphabetic substitution cipher. To decrypt, each letter in an alphabet is mapped to its numeric equivalent, decrypted by a mathematical function, and converted back to a letter.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Affine_cipher";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class AffineCipherEncode extends Operation {
|
|||
this.name = "Affine Cipher Encode";
|
||||
this.module = "Ciphers";
|
||||
this.description = "The Affine cipher is a type of monoalphabetic substitution cipher, wherein each letter in an alphabet is mapped to its numeric equivalent, encrypted using simple mathematical function, <code>(ax + b) % 26</code>, and converted back to a letter.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Affine_cipher";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class AnalyseHash extends Operation {
|
|||
this.name = "Analyse hash";
|
||||
this.module = "Hashing";
|
||||
this.description = "Tries to determine information about a given hash and suggests which algorithm may have been used to generate it based on its length.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Comparison_of_cryptographic_hash_functions";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class AtbashCipher extends Operation {
|
|||
this.name = "Atbash Cipher";
|
||||
this.module = "Ciphers";
|
||||
this.description = "Atbash is a mono-alphabetic substitution cipher originally used to encode the Hebrew alphabet. It has been modified here for use with the Latin alphabet.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Atbash";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class BSONDeserialise extends Operation {
|
|||
this.name = "BSON deserialise";
|
||||
this.module = "BSON";
|
||||
this.description = "BSON is a computer data interchange format used mainly as a data storage and network transfer format in the MongoDB database. It is a binary form for representing simple data structures, associative arrays (called objects or documents in MongoDB), and various data types of specific interest to MongoDB. The name 'BSON' is based on the term JSON and stands for 'Binary JSON'.<br><br>Input data should be in a raw bytes format.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/BSON";
|
||||
this.inputType = "ArrayBuffer";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class BSONSerialise extends Operation {
|
|||
this.name = "BSON serialise";
|
||||
this.module = "BSON";
|
||||
this.description = "BSON is a computer data interchange format used mainly as a data storage and network transfer format in the MongoDB database. It is a binary form for representing simple data structures, associative arrays (called objects or documents in MongoDB), and various data types of specific interest to MongoDB. The name 'BSON' is based on the term JSON and stands for 'Binary JSON'.<br><br>Input data should be valid JSON.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/BSON";
|
||||
this.inputType = "string";
|
||||
this.outputType = "ArrayBuffer";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class Bcrypt extends Operation {
|
|||
this.name = "Bcrypt";
|
||||
this.module = "Hashing";
|
||||
this.description = "bcrypt is a password hashing function designed by Niels Provos and David Mazi\xe8res, based on the Blowfish cipher, and presented at USENIX in 1999. Besides incorporating a salt to protect against rainbow table attacks, bcrypt is an adaptive function: over time, the iteration count (rounds) can be increased to make it slower, so it remains resistant to brute-force search attacks even with increasing computation power.<br><br>Enter the password in the input to generate its hash.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Bcrypt";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class BcryptCompare extends Operation {
|
|||
this.name = "Bcrypt compare";
|
||||
this.module = "Hashing";
|
||||
this.description = "Tests whether the input matches the given bcrypt hash. To test multiple possible passwords, use the 'Fork' operation.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Bcrypt";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class BcryptParse extends Operation {
|
|||
this.name = "Bcrypt parse";
|
||||
this.module = "Hashing";
|
||||
this.description = "Parses a bcrypt hash to determine the number of rounds used, the salt, and the password hash.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Bcrypt";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class BifidCipherDecode extends Operation {
|
|||
this.name = "Bifid Cipher Decode";
|
||||
this.module = "Ciphers";
|
||||
this.description = "The Bifid cipher is a cipher which uses a Polybius square in conjunction with transposition, which can be fairly difficult to decipher without knowing the alphabet keyword.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Bifid_cipher";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class BifidCipherEncode extends Operation {
|
|||
this.name = "Bifid Cipher Encode";
|
||||
this.module = "Ciphers";
|
||||
this.description = "The Bifid cipher is a cipher which uses a Polybius square in conjunction with transposition, which can be fairly difficult to decipher without knowing the alphabet keyword.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Bifid_cipher";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ class BitShiftLeft extends Operation {
|
|||
this.name = "Bit shift left";
|
||||
this.module = "Default";
|
||||
this.description = "Shifts the bits in each byte towards the left by the specified amount.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Bitwise_operation#Bit_shifts";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ class BitShiftRight extends Operation {
|
|||
this.name = "Bit shift right";
|
||||
this.module = "Default";
|
||||
this.description = "Shifts the bits in each byte towards the right by the specified amount.<br><br><i>Logical shifts</i> replace the leftmost bits with zeros.<br><i>Arithmetic shifts</i> preserve the most significant bit (MSB) of the original byte keeping the sign the same (positive or negative).";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Bitwise_operation#Bit_shifts";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -38,6 +38,7 @@ class BlowfishDecrypt extends Operation {
|
|||
this.name = "Blowfish Decrypt";
|
||||
this.module = "Ciphers";
|
||||
this.description = "Blowfish is a symmetric-key block cipher designed in 1993 by Bruce Schneier and included in a large number of cipher suites and encryption products. AES now receives more attention.<br><br><b>IV:</b> The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Blowfish_(cipher)";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@ class BlowfishEncrypt extends Operation {
|
|||
this.name = "Blowfish Encrypt";
|
||||
this.module = "Ciphers";
|
||||
this.description = "Blowfish is a symmetric-key block cipher designed in 1993 by Bruce Schneier and included in a large number of cipher suites and encryption products. AES now receives more attention.<br><br><b>IV:</b> The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Blowfish_(cipher)";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class Bzip2Decompress extends Operation {
|
|||
this.name = "Bzip2 Decompress";
|
||||
this.module = "Compression";
|
||||
this.description = "Decompresses data using the Bzip2 algorithm.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Bzip2";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class CRC16Checksum extends Operation {
|
|||
this.name = "CRC-16 Checksum";
|
||||
this.module = "Hashing";
|
||||
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.<br><br>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 = [];
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class CRC32Checksum extends Operation {
|
|||
this.name = "CRC-32 Checksum";
|
||||
this.module = "Hashing";
|
||||
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.<br><br>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 = [];
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ class CSSSelector extends Operation {
|
|||
this.name = "CSS selector";
|
||||
this.module = "Code";
|
||||
this.description = "Extract information from an HTML document with a CSS selector";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Cascading_Style_Sheets#Selector";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class CTPH extends Operation {
|
|||
this.name = "CTPH";
|
||||
this.module = "Hashing";
|
||||
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.<br><br>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.org/wiki/Context_Triggered_Piecewise_Hashing";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class CartesianProduct extends Operation {
|
|||
this.name = "Cartesian Product";
|
||||
this.module = "Default";
|
||||
this.description = "Calculates the cartesian product of multiple sets of data, returning all possible combinations.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Cartesian_product";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ class ChangeIPFormat extends Operation {
|
|||
super();
|
||||
|
||||
this.name = "Change IP format";
|
||||
this.module = "JSBN";
|
||||
this.module = "Default";
|
||||
this.description = "Convert an IP address from one format to another, e.g. <code>172.20.23.54</code> to <code>ac141736</code>";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
|
|
@ -29,12 +29,12 @@ class ChangeIPFormat extends Operation {
|
|||
{
|
||||
"name": "Input format",
|
||||
"type": "option",
|
||||
"value": ["Hex", "Raw"]
|
||||
"value": ["Dotted Decimal", "Decimal", "Hex"]
|
||||
},
|
||||
{
|
||||
"name": "Output format",
|
||||
"type": "option",
|
||||
"value": ["Hex", "Raw"]
|
||||
"value": ["Dotted Decimal", "Decimal", "Hex"]
|
||||
}
|
||||
];
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ class ChiSquare extends Operation {
|
|||
this.name = "Chi Square";
|
||||
this.module = "Default";
|
||||
this.description = "Calculates the Chi Square distribution of values.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Chi-squared_distribution";
|
||||
this.inputType = "ArrayBuffer";
|
||||
this.outputType = "number";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@ class CompareCTPHHashes extends Operation {
|
|||
this.name = "Compare CTPH hashes";
|
||||
this.module = "Hashing";
|
||||
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.org/wiki/Context_Triggered_Piecewise_Hashing";
|
||||
this.inputType = "string";
|
||||
this.outputType = "Number";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@ class CompareSSDEEPHashes extends Operation {
|
|||
this.name = "Compare SSDEEP hashes";
|
||||
this.module = "Hashing";
|
||||
this.description = "Compares two SSDEEP fuzzy hashes to determine the similarity between them on a scale of 0 to 100.";
|
||||
this.infoURL = "https://forensicswiki.org/wiki/Ssdeep";
|
||||
this.inputType = "string";
|
||||
this.outputType = "Number";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ class ConvertArea extends Operation {
|
|||
this.name = "Convert area";
|
||||
this.module = "Default";
|
||||
this.description = "Converts a unit of area to another format.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Orders_of_magnitude_(area)";
|
||||
this.inputType = "BigNumber";
|
||||
this.outputType = "BigNumber";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ class ConvertDataUnits extends Operation {
|
|||
this.name = "Convert data units";
|
||||
this.module = "Default";
|
||||
this.description = "Converts a unit of data to another format.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Orders_of_magnitude_(data)";
|
||||
this.inputType = "BigNumber";
|
||||
this.outputType = "BigNumber";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ class ConvertDistance extends Operation {
|
|||
this.name = "Convert distance";
|
||||
this.module = "Default";
|
||||
this.description = "Converts a unit of distance to another format.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Orders_of_magnitude_(length)";
|
||||
this.inputType = "BigNumber";
|
||||
this.outputType = "BigNumber";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ class ConvertMass extends Operation {
|
|||
this.name = "Convert mass";
|
||||
this.module = "Default";
|
||||
this.description = "Converts a unit of mass to another format.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Orders_of_magnitude_(mass)";
|
||||
this.inputType = "BigNumber";
|
||||
this.outputType = "BigNumber";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ class ConvertSpeed extends Operation {
|
|||
this.name = "Convert speed";
|
||||
this.module = "Default";
|
||||
this.description = "Converts a unit of speed to another format.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Orders_of_magnitude_(speed)";
|
||||
this.inputType = "BigNumber";
|
||||
this.outputType = "BigNumber";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -23,6 +23,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.<br><br><b>Key:</b> DES uses a key length of 8 bytes (64 bits).<br>Triple DES uses a key length of 24 bytes (192 bits).<br><br><b>IV:</b> The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.<br><br><b>Padding:</b> 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";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -23,6 +23,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.<br><br><b>Key:</b> DES uses a key length of 8 bytes (64 bits).<br>Triple DES uses a key length of 24 bytes (192 bits).<br><br>You can generate a password-based key using one of the KDF operations.<br><br><b>IV:</b> The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.<br><br><b>Padding:</b> 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";
|
||||
this.args = [
|
||||
|
|
|
|||
51
src/core/operations/DechunkHTTPResponse.mjs
Normal file
51
src/core/operations/DechunkHTTPResponse.mjs
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
/**
|
||||
* @author sevzero [sevzero@protonmail.com]
|
||||
* @copyright Crown Copyright 2018
|
||||
* @license Apache-2.0
|
||||
*/
|
||||
|
||||
import Operation from "../Operation";
|
||||
|
||||
/**
|
||||
* Dechunk HTTP response operation
|
||||
*/
|
||||
class DechunkHTTPResponse extends Operation {
|
||||
|
||||
/**
|
||||
* DechunkHTTPResponse constructor
|
||||
*/
|
||||
constructor() {
|
||||
super();
|
||||
|
||||
this.name = "Dechunk HTTP response";
|
||||
this.module = "Default";
|
||||
this.description = "Parses an HTTP response transferred using Transfer-Encoding: Chunked";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Chunked_transfer_encoding";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} input
|
||||
* @param {Object[]} args
|
||||
* @returns {string}
|
||||
*/
|
||||
run(input, args) {
|
||||
const chunks = [];
|
||||
let chunkSizeEnd = input.indexOf("\n") + 1;
|
||||
const lineEndings = input.charAt(chunkSizeEnd - 2) === "\r" ? "\r\n" : "\n";
|
||||
const lineEndingsLength = lineEndings.length;
|
||||
let chunkSize = parseInt(input.slice(0, chunkSizeEnd), 16);
|
||||
while (!isNaN(chunkSize)) {
|
||||
chunks.push(input.slice(chunkSizeEnd, chunkSize + chunkSizeEnd));
|
||||
input = input.slice(chunkSizeEnd + chunkSize + lineEndingsLength);
|
||||
chunkSizeEnd = input.indexOf(lineEndings) + lineEndingsLength;
|
||||
chunkSize = parseInt(input.slice(0, chunkSizeEnd), 16);
|
||||
}
|
||||
return chunks.join("") + input;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
export default DechunkHTTPResponse;
|
||||
|
|
@ -20,6 +20,7 @@ class DecodeNetBIOSName extends Operation {
|
|||
this.name = "Decode NetBIOS Name";
|
||||
this.module = "Default";
|
||||
this.description = "NetBIOS names as seen across the client interface to NetBIOS are exactly 16 bytes long. Within the NetBIOS-over-TCP protocols, a longer representation is used.<br><br>There are two levels of encoding. The first level maps a NetBIOS name into a domain system name. The second level maps the domain system name into the 'compressed' representation required for interaction with the domain name system.<br><br>This operation decodes the first level of encoding. See RFC 1001 for full details.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/NetBIOS";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -29,6 +29,7 @@ class DecodeText extends Operation {
|
|||
Object.keys(IO_FORMAT).map(e => `<li>${e}</li>`).join("\n"),
|
||||
"</ul>",
|
||||
].join("\n");
|
||||
this.infoURL = "https://wikipedia.org/wiki/Character_encoding";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,7 +21,8 @@ class DeriveEVPKey extends Operation {
|
|||
|
||||
this.name = "Derive EVP key";
|
||||
this.module = "Ciphers";
|
||||
this.description = "EVP is a password-based key derivation function (PBKDF) used extensively in OpenSSL. In many applications of cryptography, user security is ultimately dependent on a password, and because a password usually can't be used directly as a cryptographic key, some processing is required.<br><br>A salt provides a large set of keys for any given password, and an iteration count increases the cost of producing keys from a password, thereby also increasing the difficulty of attack.<br><br>If you leave the salt argument empty, a random salt will be generated.";
|
||||
this.description = "This operation performs a password-based key derivation function (PBKDF) used extensively in OpenSSL. In many applications of cryptography, user security is ultimately dependent on a password, and because a password usually can't be used directly as a cryptographic key, some processing is required.<br><br>A salt provides a large set of keys for any given password, and an iteration count increases the cost of producing keys from a password, thereby also increasing the difficulty of attack.<br><br>If you leave the salt argument empty, a random salt will be generated.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Key_derivation_function";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class DerivePBKDF2Key extends Operation {
|
|||
this.name = "Derive PBKDF2 key";
|
||||
this.module = "Ciphers";
|
||||
this.description = "PBKDF2 is a password-based key derivation function. It is part of RSA Laboratories' Public-Key Cryptography Standards (PKCS) series, specifically PKCS #5 v2.0, also published as Internet Engineering Task Force's RFC 2898.<br><br>In many applications of cryptography, user security is ultimately dependent on a password, and because a password usually can't be used directly as a cryptographic key, some processing is required.<br><br>A salt provides a large set of keys for any given password, and an iteration count increases the cost of producing keys from a password, thereby also increasing the difficulty of attack.<br><br>If you leave the salt argument empty, a random salt will be generated.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/PBKDF2";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class DetectFileType extends Operation {
|
|||
this.name = "Detect File Type";
|
||||
this.module = "Default";
|
||||
this.description = "Attempts to guess the MIME (Multipurpose Internet Mail Extensions) type of the data based on 'magic bytes'.<br><br>Currently supports the following file types: 7z, amr, avi, bmp, bz2, class, cr2, crx, dex, dmg, doc, elf, eot, epub, exe, flac, flv, gif, gz, ico, iso, jpg, jxr, m4a, m4v, mid, mkv, mov, mp3, mp4, mpg, ogg, otf, pdf, png, ppt, ps, psd, rar, rtf, sqlite, swf, tar, tar.z, tif, ttf, utf8, vmdk, wav, webm, webp, wmv, woff, woff2, xls, xz, zip.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/List_of_file_signatures";
|
||||
this.inputType = "ArrayBuffer";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ class Diff extends Operation {
|
|||
this.name = "Diff";
|
||||
this.module = "Diff";
|
||||
this.description = "Compares two inputs (separated by the specified delimiter) and highlights the differences between them.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/File_comparison";
|
||||
this.inputType = "string";
|
||||
this.outputType = "html";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class DisassembleX86 extends Operation {
|
|||
this.name = "Disassemble x86";
|
||||
this.module = "Shellcode";
|
||||
this.description = "Disassembly is the process of translating machine language into assembly language.<br><br>This operation supports 64-bit, 32-bit and 16-bit code written for Intel or AMD x86 processors. It is particularly useful for reverse engineering shellcode.<br><br>Input should be in hexadecimal.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/X86";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -5,7 +5,6 @@
|
|||
*/
|
||||
|
||||
import Operation from "../Operation";
|
||||
import OperationError from "../errors/OperationError";
|
||||
|
||||
/**
|
||||
* Drop bytes operation
|
||||
|
|
@ -20,7 +19,7 @@ class DropBytes extends Operation {
|
|||
|
||||
this.name = "Drop bytes";
|
||||
this.module = "Default";
|
||||
this.description = "Cuts a slice of the specified number of bytes out of the data.";
|
||||
this.description = "Cuts a slice of the specified number of bytes out of the data. Negative values are allowed.";
|
||||
this.inputType = "ArrayBuffer";
|
||||
this.outputType = "ArrayBuffer";
|
||||
this.args = [
|
||||
|
|
@ -50,14 +49,25 @@ class DropBytes extends Operation {
|
|||
* @throws {OperationError} if invalid input
|
||||
*/
|
||||
run(input, args) {
|
||||
const start = args[0],
|
||||
length = args[1],
|
||||
applyToEachLine = args[2];
|
||||
|
||||
if (start < 0 || length < 0)
|
||||
throw new OperationError("Error: Invalid value");
|
||||
let start = args[0],
|
||||
length = args[1];
|
||||
const applyToEachLine = args[2];
|
||||
|
||||
if (!applyToEachLine) {
|
||||
if (start < 0) { // Take from the end
|
||||
start = input.byteLength + start;
|
||||
}
|
||||
|
||||
if (length < 0) { // Flip start point
|
||||
start = start + length;
|
||||
if (start < 0) {
|
||||
start = input.byteLength + start;
|
||||
length = start - length;
|
||||
} else {
|
||||
length = -length;
|
||||
}
|
||||
}
|
||||
|
||||
const left = input.slice(0, start),
|
||||
right = input.slice(start + length, input.byteLength);
|
||||
const result = new Uint8Array(left.byteLength + right.byteLength);
|
||||
|
|
@ -82,10 +92,28 @@ class DropBytes extends Operation {
|
|||
}
|
||||
lines.push(line);
|
||||
|
||||
let output = [];
|
||||
let output = [],
|
||||
s = start,
|
||||
l = length;
|
||||
for (i = 0; i < lines.length; i++) {
|
||||
output = output.concat(lines[i].slice(0, start).concat(lines[i].slice(start+length, lines[i].length)));
|
||||
if (s < 0) { // Take from the end
|
||||
s = lines[i].length + s;
|
||||
}
|
||||
|
||||
if (l < 0) { // Flip start point
|
||||
s = s + l;
|
||||
if (s < 0) {
|
||||
s = lines[i].length + s;
|
||||
l = s - l;
|
||||
} else {
|
||||
l = -l;
|
||||
}
|
||||
}
|
||||
|
||||
output = output.concat(lines[i].slice(0, s).concat(lines[i].slice(s+l, lines[i].length)));
|
||||
output.push(0x0a);
|
||||
s = start;
|
||||
l = length;
|
||||
}
|
||||
return new Uint8Array(output.slice(0, output.length-1)).buffer;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ class EncodeNetBIOSName extends Operation {
|
|||
this.name = "Encode NetBIOS Name";
|
||||
this.module = "Default";
|
||||
this.description = "NetBIOS names as seen across the client interface to NetBIOS are exactly 16 bytes long. Within the NetBIOS-over-TCP protocols, a longer representation is used.<br><br>There are two levels of encoding. The first level maps a NetBIOS name into a domain system name. The second level maps the domain system name into the 'compressed' representation required for interaction with the domain name system.<br><br>This operation carries out the first level of encoding. See RFC 1001 for full details.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/NetBIOS";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -29,6 +29,7 @@ class EncodeText extends Operation {
|
|||
Object.keys(IO_FORMAT).map(e => `<li>${e}</li>`).join("\n"),
|
||||
"</ul>",
|
||||
].join("\n");
|
||||
this.infoURL = "https://wikipedia.org/wiki/Character_encoding";
|
||||
this.inputType = "string";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class Entropy extends Operation {
|
|||
this.name = "Entropy";
|
||||
this.module = "Default";
|
||||
this.description = "Shannon Entropy, in the context of information theory, is a measure of the rate at which information is produced by a source of data. It can be used, in a broad sense, to detect whether data is likely to be structured or unstructured. 8 is the maximum, representing highly unstructured, 'random' data. English language text usually falls somewhere between 3.5 and 5. Properly encrypted or compressed data should have an entropy of over 7.5.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Entropy_(information_theory)";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "number";
|
||||
this.presentType = "html";
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class EscapeString extends Operation {
|
|||
this.name = "Escape string";
|
||||
this.module = "Default";
|
||||
this.description = "Escapes special characters in a string so that they do not cause conflicts. For example, <code>Don't stop me now</code> becomes <code>Don\\'t stop me now</code>.<br><br>Supports the following escape sequences:<ul><li><code>\\n</code> (Line feed/newline)</li><li><code>\\r</code> (Carriage return)</li><li><code>\\t</code> (Horizontal tab)</li><li><code>\\b</code> (Backspace)</li><li><code>\\f</code> (Form feed)</li><li><code>\\xnn</code> (Hex, where n is 0-f)</li><li><code>\\\\</code> (Backslash)</li><li><code>\\'</code> (Single quote)</li><li><code>\\"</code> (Double quote)</li><li><code>\\unnnn</code> (Unicode character)</li><li><code>\\u{nnnnnn}</code> (Unicode code point)</li></ul>";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Escape_sequence";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@ class ExtractEXIF extends Operation {
|
|||
"<br><br>",
|
||||
"EXIF data from photos usually contains information about the image file itself as well as the device used to create it.",
|
||||
].join("\n");
|
||||
this.infoURL = "https://wikipedia.org/wiki/Exif";
|
||||
this.inputType = "ArrayBuffer";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ import Operation from "../Operation";
|
|||
import Utils from "../Utils";
|
||||
import {INPUT_DELIM_OPTIONS} from "../lib/Delim";
|
||||
import OperationError from "../errors/OperationError";
|
||||
import XRegExp from "xregexp";
|
||||
|
||||
/**
|
||||
* Filter operation
|
||||
|
|
@ -21,7 +22,7 @@ class Filter extends Operation {
|
|||
super();
|
||||
|
||||
this.name = "Filter";
|
||||
this.module = "Default";
|
||||
this.module = "Regex";
|
||||
this.description = "Splits up the input using the specified delimiter and then filters each branch based on a regular expression.";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
|
|
@ -55,7 +56,7 @@ class Filter extends Operation {
|
|||
let regex;
|
||||
|
||||
try {
|
||||
regex = new RegExp(args[1]);
|
||||
regex = new XRegExp(args[1]);
|
||||
} catch (err) {
|
||||
throw new OperationError(`Invalid regex. Details: ${err.message}`);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
|
||||
import Operation from "../Operation";
|
||||
import Utils from "../Utils";
|
||||
import XRegExp from "xregexp";
|
||||
|
||||
/**
|
||||
* Find / Replace operation
|
||||
|
|
@ -21,6 +22,7 @@ class FindReplace extends Operation {
|
|||
this.name = "Find / Replace";
|
||||
this.module = "Regex";
|
||||
this.description = "Replaces all occurrences of the first string with the second.<br><br>Includes support for regular expressions (regex), simple strings and extended strings (which support \\n, \\r, \\t, \\b, \\f and escaped hex bytes using \\x notation, e.g. \\x00 for a null byte).";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Regular_expression";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
@ -49,6 +51,11 @@ class FindReplace extends Operation {
|
|||
"name": "Multiline matching",
|
||||
"type": "boolean",
|
||||
"value": true
|
||||
},
|
||||
{
|
||||
"name": "Dot matches all",
|
||||
"type": "boolean",
|
||||
"value": false
|
||||
}
|
||||
];
|
||||
}
|
||||
|
|
@ -59,16 +66,17 @@ class FindReplace extends Operation {
|
|||
* @returns {string}
|
||||
*/
|
||||
run(input, args) {
|
||||
const [{option: type}, replace, g, i, m] = args;
|
||||
const [{option: type}, replace, g, i, m, s] = args;
|
||||
let find = args[0].string,
|
||||
modifiers = "";
|
||||
|
||||
if (g) modifiers += "g";
|
||||
if (i) modifiers += "i";
|
||||
if (m) modifiers += "m";
|
||||
if (s) modifiers += "s";
|
||||
|
||||
if (type === "Regex") {
|
||||
find = new RegExp(find, modifiers);
|
||||
find = new XRegExp(find, modifiers);
|
||||
return input.replace(find, replace);
|
||||
}
|
||||
|
||||
|
|
@ -76,7 +84,7 @@ class FindReplace extends Operation {
|
|||
find = Utils.parseEscapedChars(find);
|
||||
}
|
||||
|
||||
find = new RegExp(Utils.escapeRegex(find), modifiers);
|
||||
find = new XRegExp(Utils.escapeRegex(find), modifiers);
|
||||
|
||||
return input.replace(find, replace);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class Fletcher16Checksum extends Operation {
|
|||
this.name = "Fletcher-16 Checksum";
|
||||
this.module = "Hashing";
|
||||
this.description = "The Fletcher checksum is an algorithm for computing a position-dependent checksum devised by John Gould Fletcher at Lawrence Livermore Labs in the late 1970s.<br><br>The objective of the Fletcher checksum was to provide error-detection properties approaching those of a cyclic redundancy check but with the lower computational effort associated with summation techniques.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Fletcher%27s_checksum#Fletcher-16";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class Fletcher32Checksum extends Operation {
|
|||
this.name = "Fletcher-32 Checksum";
|
||||
this.module = "Hashing";
|
||||
this.description = "The Fletcher checksum is an algorithm for computing a position-dependent checksum devised by John Gould Fletcher at Lawrence Livermore Labs in the late 1970s.<br><br>The objective of the Fletcher checksum was to provide error-detection properties approaching those of a cyclic redundancy check but with the lower computational effort associated with summation techniques.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Fletcher%27s_checksum#Fletcher-32";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class Fletcher64Checksum extends Operation {
|
|||
this.name = "Fletcher-64 Checksum";
|
||||
this.module = "Hashing";
|
||||
this.description = "The Fletcher checksum is an algorithm for computing a position-dependent checksum devised by John Gould Fletcher at Lawrence Livermore Labs in the late 1970s.<br><br>The objective of the Fletcher checksum was to provide error-detection properties approaching those of a cyclic redundancy check but with the lower computational effort associated with summation techniques.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Fletcher%27s_checksum#Fletcher-64";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class Fletcher8Checksum extends Operation {
|
|||
this.name = "Fletcher-8 Checksum";
|
||||
this.module = "Hashing";
|
||||
this.description = "The Fletcher checksum is an algorithm for computing a position-dependent checksum devised by John Gould Fletcher at Lawrence Livermore Labs in the late 1970s.<br><br>The objective of the Fletcher checksum was to provide error-detection properties approaching those of a cyclic redundancy check but with the lower computational effort associated with summation techniques.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Fletcher%27s_checksum";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ class FormatMACAddresses extends Operation {
|
|||
this.name = "Format MAC addresses";
|
||||
this.module = "Default";
|
||||
this.description = "Displays given MAC addresses in multiple different formats.<br><br>Expects addresses in a list separated by newlines, spaces or commas.<br><br>WARNING: There are no validity checks.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/MAC_address#Notational_conventions";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class FrequencyDistribution extends Operation {
|
|||
this.name = "Frequency distribution";
|
||||
this.module = "Default";
|
||||
this.description = "Displays the distribution of bytes in the data as a graph.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Frequency_distribution";
|
||||
this.inputType = "ArrayBuffer";
|
||||
this.outputType = "json";
|
||||
this.presentType = "html";
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@ class FromBCD extends Operation {
|
|||
this.name = "From BCD";
|
||||
this.module = "Default";
|
||||
this.description = "Binary-Coded Decimal (BCD) is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of bits, usually four or eight. Special bit patterns are sometimes used for a sign.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Binary-coded_decimal";
|
||||
this.inputType = "string";
|
||||
this.outputType = "BigNumber";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class FromBase extends Operation {
|
|||
this.name = "From Base";
|
||||
this.module = "Default";
|
||||
this.description = "Converts a number to decimal from a given numerical base.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Radix";
|
||||
this.inputType = "string";
|
||||
this.outputType = "BigNumber";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class FromBase32 extends Operation {
|
|||
this.name = "From Base32";
|
||||
this.module = "Default";
|
||||
this.description = "Base32 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers. It uses a smaller set of characters than Base64, usually the uppercase alphabet and the numbers 2 to 7.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Base32";
|
||||
this.inputType = "string";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ class FromBase58 extends Operation {
|
|||
this.name = "From Base58";
|
||||
this.module = "Default";
|
||||
this.description = "Base58 (similar to Base64) is a notation for encoding arbitrary byte data. It differs from Base64 by removing easily misread characters (i.e. l, I, 0 and O) to improve human readability.<br><br>This operation decodes data from an ASCII string (with an alphabet of your choosing, presets included) back into its raw form.<br><br>e.g. <code>StV1DL6CwTryKyV</code> becomes <code>hello world</code><br><br>Base58 is commonly used in cryptocurrencies (Bitcoin, Ripple, etc).";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Base58";
|
||||
this.inputType = "string";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class FromBase64 extends Operation {
|
|||
this.name = "From Base64";
|
||||
this.module = "Default";
|
||||
this.description = "Base64 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers.<br><br>This operation decodes data from an ASCII Base64 string back into its raw format.<br><br>e.g. <code>aGVsbG8=</code> becomes <code>hello</code>";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Base64";
|
||||
this.inputType = "string";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
|
|||
105
src/core/operations/FromBase85.mjs
Normal file
105
src/core/operations/FromBase85.mjs
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
/**
|
||||
* @author PenguinGeorge [george@penguingeorge.com]
|
||||
* @copyright Crown Copyright 2018
|
||||
* @license Apache-2.0
|
||||
*/
|
||||
|
||||
import Operation from "../Operation";
|
||||
import OperationError from "../errors/OperationError";
|
||||
import Utils from "../Utils";
|
||||
import {alphabetName, ALPHABET_OPTIONS} from "../lib/Base85";
|
||||
|
||||
/**
|
||||
* From Base85 operation
|
||||
*/
|
||||
class FromBase85 extends Operation {
|
||||
|
||||
/**
|
||||
* From Base85 constructor
|
||||
*/
|
||||
constructor() {
|
||||
super();
|
||||
|
||||
this.name = "From Base85";
|
||||
this.module = "Default";
|
||||
this.description = "Base85 (also called Ascii85) is a notation for encoding arbitrary byte data. It is usually more efficient that Base64.<br><br>This operation decodes data from an ASCII string (with an alphabet of your choosing, presets included).<br><br>e.g. <code>BOu!rD]j7BEbo7</code> becomes <code>hello world</code><br><br>Base85 is commonly used in Adobe's PostScript and PDF file formats.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Ascii85";
|
||||
this.inputType = "string";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
{
|
||||
name: "Alphabet",
|
||||
type: "editableOption",
|
||||
value: ALPHABET_OPTIONS
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} input
|
||||
* @param {Object[]} args
|
||||
* @returns {byteArray}
|
||||
*/
|
||||
run(input, args) {
|
||||
const alphabet = Utils.expandAlphRange(args[0]).join(""),
|
||||
encoding = alphabetName(alphabet),
|
||||
result = [];
|
||||
|
||||
if (alphabet.length !== 85 ||
|
||||
[].unique.call(alphabet).length !== 85) {
|
||||
throw new OperationError("Alphabet must be of length 85");
|
||||
}
|
||||
|
||||
if (input.length === 0) return [];
|
||||
|
||||
const matches = input.match(/<~(.+?)~>/);
|
||||
if (matches !== null) input = matches[1];
|
||||
|
||||
let i = 0;
|
||||
let block, blockBytes;
|
||||
while (i < input.length) {
|
||||
if (encoding === "Standard" && input[i] === "z") {
|
||||
result.push(0, 0, 0, 0);
|
||||
i++;
|
||||
} else {
|
||||
let digits = [];
|
||||
digits = input
|
||||
.substr(i, 5)
|
||||
.split("")
|
||||
.map((chr, idx) => {
|
||||
const digit = alphabet.indexOf(chr);
|
||||
if (digit < 0 || digit > 84) {
|
||||
throw `Invalid character '${chr}' at index ${idx}`;
|
||||
}
|
||||
return digit;
|
||||
});
|
||||
|
||||
block =
|
||||
digits[0] * 52200625 +
|
||||
digits[1] * 614125 +
|
||||
(i + 2 < input.length ? digits[2] : 84) * 7225 +
|
||||
(i + 3 < input.length ? digits[3] : 84) * 85 +
|
||||
(i + 4 < input.length ? digits[4] : 84);
|
||||
|
||||
blockBytes = [
|
||||
(block >> 24) & 0xff,
|
||||
(block >> 16) & 0xff,
|
||||
(block >> 8) & 0xff,
|
||||
block & 0xff
|
||||
];
|
||||
|
||||
if (input.length < i + 5) {
|
||||
blockBytes.splice(input.length - (i + 5), 5);
|
||||
}
|
||||
|
||||
result.push.apply(result, blockBytes);
|
||||
i += 5;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
export default FromBase85;
|
||||
|
|
@ -22,6 +22,7 @@ class FromBinary extends Operation {
|
|||
this.name = "From Binary";
|
||||
this.module = "Default";
|
||||
this.description = "Converts a binary string back into its raw form.<br><br>e.g. <code>01001000 01101001</code> becomes <code>Hi</code>";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Binary_code";
|
||||
this.inputType = "string";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
|
|||
70
src/core/operations/FromBraille.mjs
Normal file
70
src/core/operations/FromBraille.mjs
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
/**
|
||||
* @author n1474335 [n1474335@gmail.com]
|
||||
* @copyright Crown Copyright 2018
|
||||
* @license Apache-2.0
|
||||
*/
|
||||
|
||||
import Operation from "../Operation";
|
||||
import {BRAILLE_LOOKUP} from "../lib/Braille";
|
||||
|
||||
/**
|
||||
* From Braille operation
|
||||
*/
|
||||
class FromBraille extends Operation {
|
||||
|
||||
/**
|
||||
* FromBraille constructor
|
||||
*/
|
||||
constructor() {
|
||||
super();
|
||||
|
||||
this.name = "From Braille";
|
||||
this.module = "Default";
|
||||
this.description = "Converts six-dot braille symbols to text.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Braille";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} input
|
||||
* @param {Object[]} args
|
||||
* @returns {string}
|
||||
*/
|
||||
run(input, args) {
|
||||
return input.split("").map(b => {
|
||||
const idx = BRAILLE_LOOKUP.dot6.indexOf(b);
|
||||
return idx < 0 ? b : BRAILLE_LOOKUP.ascii[idx];
|
||||
}).join("");
|
||||
}
|
||||
|
||||
/**
|
||||
* Highlight From Braille
|
||||
*
|
||||
* @param {Object[]} pos
|
||||
* @param {number} pos[].start
|
||||
* @param {number} pos[].end
|
||||
* @param {Object[]} args
|
||||
* @returns {Object[]} pos
|
||||
*/
|
||||
highlight(pos, args) {
|
||||
return pos;
|
||||
}
|
||||
|
||||
/**
|
||||
* Highlight From Braille in reverse
|
||||
*
|
||||
* @param {Object[]} pos
|
||||
* @param {number} pos[].start
|
||||
* @param {number} pos[].end
|
||||
* @param {Object[]} args
|
||||
* @returns {Object[]} pos
|
||||
*/
|
||||
highlightReverse(pos, args) {
|
||||
return pos;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
export default FromBraille;
|
||||
|
|
@ -23,6 +23,7 @@ class FromCharcode extends Operation {
|
|||
this.name = "From Charcode";
|
||||
this.module = "Default";
|
||||
this.description = "Converts unicode character codes back into text.<br><br>e.g. <code>0393 03b5 03b9 03ac 20 03c3 03bf 03c5</code> becomes <code>Γειά σου</code>";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Plane_(Unicode)";
|
||||
this.inputType = "string";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -5,8 +5,8 @@
|
|||
*/
|
||||
|
||||
import Operation from "../Operation";
|
||||
import Utils from "../Utils";
|
||||
import {DELIM_OPTIONS} from "../lib/Delim";
|
||||
import {fromDecimal} from "../lib/Decimal";
|
||||
|
||||
/**
|
||||
* From Decimal operation
|
||||
|
|
@ -71,16 +71,7 @@ class FromDecimal extends Operation {
|
|||
* @returns {byteArray}
|
||||
*/
|
||||
run(input, args) {
|
||||
const delim = Utils.charRep(args[0]),
|
||||
output = [];
|
||||
let byteStr = input.split(delim);
|
||||
if (byteStr[byteStr.length-1] === "")
|
||||
byteStr = byteStr.slice(0, byteStr.length-1);
|
||||
|
||||
for (let i = 0; i < byteStr.length; i++) {
|
||||
output[i] = parseInt(byteStr[i], 10);
|
||||
}
|
||||
return output;
|
||||
return fromDecimal(input, args[0]);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
44
src/core/operations/FromGeohash.mjs
Normal file
44
src/core/operations/FromGeohash.mjs
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
/**
|
||||
* @author gchq77703 []
|
||||
* @copyright Crown Copyright 2018
|
||||
* @license Apache-2.0
|
||||
*/
|
||||
|
||||
import Operation from "../Operation";
|
||||
import geohash from "ngeohash";
|
||||
|
||||
/**
|
||||
* From Geohash operation
|
||||
*/
|
||||
class FromGeohash extends Operation {
|
||||
|
||||
/**
|
||||
* FromGeohash constructor
|
||||
*/
|
||||
constructor() {
|
||||
super();
|
||||
|
||||
this.name = "From Geohash";
|
||||
this.module = "Hashing";
|
||||
this.description = "Converts Geohash strings into Lat/Long coordinates. For example, <code>ww8p1r4t8</code> becomes <code>37.8324,112.5584</code>.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Geohash";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} input
|
||||
* @param {Object[]} args
|
||||
* @returns {string}
|
||||
*/
|
||||
run(input, args) {
|
||||
return input.split("\n").map(line => {
|
||||
const coords = geohash.decode(line);
|
||||
return [coords.latitude, coords.longitude].join(",");
|
||||
}).join("\n");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
export default FromGeohash;
|
||||
|
|
@ -21,6 +21,7 @@ class FromHTMLEntity extends Operation {
|
|||
this.name = "From HTML Entity";
|
||||
this.module = "Default";
|
||||
this.description = "Converts HTML entities back to characters<br><br>e.g. <code>&<span>amp;</span></code> becomes <code>&</code>";
|
||||
this.infoURL = "https://wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class FromHex extends Operation {
|
|||
this.name = "From Hex";
|
||||
this.module = "Default";
|
||||
this.description = "Converts a hexadecimal byte string back into its raw value.<br><br>e.g. <code>ce 93 ce b5 ce b9 ce ac 20 cf 83 ce bf cf 85 0a</code> becomes the UTF-8 encoded string <code>Γειά σου</code>";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Hexadecimal";
|
||||
this.inputType = "string";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
@ -86,7 +87,7 @@ class FromHex extends Operation {
|
|||
* @returns {byteArray}
|
||||
*/
|
||||
run(input, args) {
|
||||
const delim = args[0] || "Space";
|
||||
const delim = args[0] || "Auto";
|
||||
return fromHex(input, delim, 2);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,8 @@ class FromHexContent extends Operation {
|
|||
|
||||
this.name = "From Hex Content";
|
||||
this.module = "Default";
|
||||
this.description = "Translates hexadecimal bytes in text back to raw bytes.<br><br>e.g. <code>foo|3d|bar</code> becomes <code>foo=bar</code>.";
|
||||
this.description = "Translates hexadecimal bytes in text back to raw bytes. This format is used by SNORT for representing hex within ASCII text.<br><br>e.g. <code>foo|3d|bar</code> becomes <code>foo=bar</code>.";
|
||||
this.infoURL = "http://manual-snort-org.s3-website-us-east-1.amazonaws.com/node32.html#SECTION00451000000000000000";
|
||||
this.inputType = "string";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class FromHexdump extends Operation {
|
|||
this.name = "From Hexdump";
|
||||
this.module = "Default";
|
||||
this.description = "Attempts to convert a hexdump back into raw data. This operation supports many different hexdump variations, but probably not all. Make sure you verify that the data it gives you is correct before continuing analysis.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Hex_dump";
|
||||
this.inputType = "string";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [];
|
||||
|
|
|
|||
47
src/core/operations/FromMessagePack.mjs
Normal file
47
src/core/operations/FromMessagePack.mjs
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
/**
|
||||
* @author Matt C [matt@artemisbot.uk]
|
||||
* @copyright Crown Copyright 2018
|
||||
* @license Apache-2.0
|
||||
*/
|
||||
|
||||
import Operation from "../Operation";
|
||||
import OperationError from "../errors/OperationError";
|
||||
import notepack from "notepack.io";
|
||||
|
||||
/**
|
||||
* From MessagePack operation
|
||||
*/
|
||||
class FromMessagePack extends Operation {
|
||||
|
||||
/**
|
||||
* FromMessagePack constructor
|
||||
*/
|
||||
constructor() {
|
||||
super();
|
||||
|
||||
this.name = "From MessagePack";
|
||||
this.module = "Code";
|
||||
this.description = "Converts MessagePack encoded data to JSON. MessagePack is a computer data interchange format. It is a binary form for representing simple data structures like arrays and associative arrays.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/MessagePack";
|
||||
this.inputType = "ArrayBuffer";
|
||||
this.outputType = "JSON";
|
||||
this.args = [];
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {ArrayBuffer} input
|
||||
* @param {Object[]} args
|
||||
* @returns {JSON}
|
||||
*/
|
||||
run(input, args) {
|
||||
try {
|
||||
const buf = Buffer.from(new Uint8Array(input));
|
||||
return notepack.decode(buf);
|
||||
} catch (err) {
|
||||
throw new OperationError(`Could not decode MessagePack to JSON: ${err}`);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
export default FromMessagePack;
|
||||
|
|
@ -22,6 +22,7 @@ class FromMorseCode extends Operation {
|
|||
this.name = "From Morse Code";
|
||||
this.module = "Default";
|
||||
this.description = "Translates Morse Code into (upper case) alphanumeric characters.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Morse_code";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class FromOctal extends Operation {
|
|||
this.name = "From Octal";
|
||||
this.module = "Default";
|
||||
this.description = "Converts an octal byte string back into its raw value.<br><br>e.g. <code>316 223 316 265 316 271 316 254 40 317 203 316 277 317 205</code> becomes the UTF-8 encoded string <code>Γειά σου</code>";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Octal";
|
||||
this.inputType = "string";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class FromPunycode extends Operation {
|
|||
this.name = "From Punycode";
|
||||
this.module = "Encodings";
|
||||
this.description = "Punycode is a way to represent Unicode with the limited character subset of ASCII supported by the Domain Name System.<br><br>e.g. <code>mnchen-3ya</code> decodes to <code>m\xfcnchen</code>";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Punycode";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@ class FromQuotedPrintable extends Operation {
|
|||
this.name = "From Quoted Printable";
|
||||
this.module = "Default";
|
||||
this.description = "Converts QP-encoded text back to standard text.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Quoted-printable";
|
||||
this.inputType = "string";
|
||||
this.outputType = "byteArray";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ class FromUNIXTimestamp extends Operation {
|
|||
this.name = "From UNIX Timestamp";
|
||||
this.module = "Default";
|
||||
this.description = "Converts a UNIX timestamp to a datetime string.<br><br>e.g. <code>978346800</code> becomes <code>Mon 1 January 2001 11:00:00 UTC</code><br><br>A UNIX timestamp is a 32-bit value representing the number of seconds since January 1, 1970 UTC (the UNIX epoch).";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Unix_time";
|
||||
this.inputType = "number";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -43,6 +43,7 @@ class GenerateAllHashes extends Operation {
|
|||
this.name = "Generate all hashes";
|
||||
this.module = "Hashing";
|
||||
this.description = "Generates all available hashes and checksums for the input.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Comparison_of_cryptographic_hash_functions";
|
||||
this.inputType = "ArrayBuffer";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class GenerateHOTP extends Operation {
|
|||
this.name = "Generate HOTP";
|
||||
this.module = "Default";
|
||||
this.description = "The HMAC-based One-Time Password algorithm (HOTP) is an algorithm that computes a one-time password from a shared secret key and an incrementing counter. It has been adopted as Internet Engineering Task Force standard RFC 4226, is the cornerstone of Initiative For Open Authentication (OATH), and is used in a number of two-factor authentication systems.<br><br>Enter the secret as the input or leave it blank for a random secret to be generated.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/HMAC-based_One-time_Password_algorithm";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@ class GeneratePGPKeyPair extends Operation {
|
|||
this.name = "Generate PGP Key Pair";
|
||||
this.module = "PGP";
|
||||
this.description = "Generates a new public/private PGP key pair. Supports RSA and Eliptic Curve (EC) keys.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Pretty_Good_Privacy";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class GenerateTOTP extends Operation {
|
|||
this.name = "Generate TOTP";
|
||||
this.module = "Default";
|
||||
this.description = "The Time-based One-Time Password algorithm (TOTP) is an algorithm that computes a one-time password from a shared secret key and the current time. It has been adopted as Internet Engineering Task Force standard RFC 6238, is the cornerstone of Initiative For Open Authentication (OATH), and is used in a number of two-factor authentication systems. A TOTP is an HOTP where the counter is the current time.<br><br>Enter the secret as the input or leave it blank for a random secret to be generated. T0 and T1 are in seconds.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Time-based_One-time_Password_algorithm";
|
||||
this.inputType = "byteArray";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class GenerateUUID extends Operation {
|
|||
this.name = "Generate UUID";
|
||||
this.module = "Crypto";
|
||||
this.description = "Generates an RFC 4122 version 4 compliant Universally Unique Identifier (UUID), also known as a Globally Unique Identifier (GUID).<br><br>A version 4 UUID relies on random numbers, in this case generated using <code>window.crypto</code> if available and falling back to <code>Math.random</code> if not.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Universally_unique_identifier";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@ class GroupIPAddresses extends Operation {
|
|||
this.name = "Group IP addresses";
|
||||
this.module = "JSBN";
|
||||
this.description = "Groups a list of IP addresses into subnets. Supports both IPv4 and IPv6 addresses.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Subnetwork";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ class Gunzip extends Operation {
|
|||
this.name = "Gunzip";
|
||||
this.module = "Compression";
|
||||
this.description = "Decompresses data which has been compressed using the deflate algorithm with gzip headers.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Gzip";
|
||||
this.inputType = "ArrayBuffer";
|
||||
this.outputType = "ArrayBuffer";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@ class Gzip extends Operation {
|
|||
this.name = "Gzip";
|
||||
this.module = "Compression";
|
||||
this.description = "Compresses data using the deflate algorithm with gzip headers.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Gzip";
|
||||
this.inputType = "ArrayBuffer";
|
||||
this.outputType = "ArrayBuffer";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class HAS160 extends Operation {
|
|||
this.name = "HAS-160";
|
||||
this.module = "Hashing";
|
||||
this.description = "HAS-160 is a cryptographic hash function designed for use with the Korean KCDSA digital signature algorithm. It is derived from SHA-1, with assorted changes intended to increase its security. It produces a 160-bit output.<br><br>HAS-160 is used in the same way as SHA-1. First it divides input in blocks of 512 bits each and pads the final block. A digest function updates the intermediate hash value by processing the input blocks in turn.<br><br>The message digest algorithm consists of 80 rounds.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/HAS-160";
|
||||
this.inputType = "ArrayBuffer";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class HMAC extends Operation {
|
|||
this.name = "HMAC";
|
||||
this.module = "Hashing";
|
||||
this.description = "Keyed-Hash Message Authentication Codes (HMAC) are a mechanism for message authentication using cryptographic hash functions.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/HMAC";
|
||||
this.inputType = "ArrayBuffer";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@ class HTTPRequest extends Operation {
|
|||
"<br><br>",
|
||||
"The status code of the response, along with a limited selection of exposed headers, can be viewed by checking the 'Show response metadata' option. Only a limited set of response headers are exposed by the browser for security reasons.",
|
||||
].join("\n");
|
||||
this.infoURL = "https://wikipedia.org/wiki/List_of_HTTP_header_fields#Request_fields";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.manualBake = true;
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ class HammingDistance extends Operation {
|
|||
this.name = "Hamming Distance";
|
||||
this.module = "Default";
|
||||
this.description = "In information theory, the Hamming distance between two strings of equal length is the number of positions at which the corresponding symbols are different. In other words, it measures the minimum number of substitutions required to change one string into the other, or the minimum number of errors that could have transformed one string into the other. In a more general context, the Hamming distance is one of several string metrics for measuring the edit distance between two sequences.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Hamming_distance";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class HaversineDistance extends Operation {
|
|||
this.name = "Haversine distance";
|
||||
this.module = "Default";
|
||||
this.description = "Returns the distance between two pairs of GPS latitude and longitude co-ordinates in metres.<br><br>e.g. <code>51.487263,-0.124323, 38.9517,-77.1467</code>";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Haversine_formula";
|
||||
this.inputType = "string";
|
||||
this.outputType = "number";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class HexToObjectIdentifier extends Operation {
|
|||
this.name = "Hex to Object Identifier";
|
||||
this.module = "PublicKey";
|
||||
this.description = "Converts a hexadecimal string into an object identifier (OID).";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Object_identifier";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [];
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ class HexToPEM extends Operation {
|
|||
this.name = "Hex to PEM";
|
||||
this.module = "PublicKey";
|
||||
this.description = "Converts a hexadecimal DER (Distinguished Encoding Rules) string into PEM (Privacy Enhanced Mail) format.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/Privacy-Enhanced_Mail";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ class JPathExpression extends Operation {
|
|||
this.name = "JPath expression";
|
||||
this.module = "Code";
|
||||
this.description = "Extract information from a JSON object with a JPath query.";
|
||||
this.infoURL = "http://goessner.net/articles/JsonPath/";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
51
src/core/operations/JWTDecode.mjs
Normal file
51
src/core/operations/JWTDecode.mjs
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
/**
|
||||
* @author gchq77703 []
|
||||
* @copyright Crown Copyright 2018
|
||||
* @license Apache-2.0
|
||||
*/
|
||||
|
||||
import Operation from "../Operation";
|
||||
import jwt from "jsonwebtoken";
|
||||
import OperationError from "../errors/OperationError";
|
||||
|
||||
/**
|
||||
* JWT Decode operation
|
||||
*/
|
||||
class JWTDecode extends Operation {
|
||||
|
||||
/**
|
||||
* JWTDecode constructor
|
||||
*/
|
||||
constructor() {
|
||||
super();
|
||||
|
||||
this.name = "JWT Decode";
|
||||
this.module = "Crypto";
|
||||
this.description = "Decodes a JSON Web Token <b>without</b> checking whether the provided secret / private key is valid. Use 'JWT Verify' to check if the signature is valid as well.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/JSON_Web_Token";
|
||||
this.inputType = "string";
|
||||
this.outputType = "JSON";
|
||||
this.args = [];
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} input
|
||||
* @param {Object[]} args
|
||||
* @returns {JSON}
|
||||
*/
|
||||
run(input, args) {
|
||||
try {
|
||||
const decoded = jwt.decode(input, {
|
||||
json: true,
|
||||
complete: true
|
||||
});
|
||||
|
||||
return decoded.payload;
|
||||
} catch (err) {
|
||||
throw new OperationError(err);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
export default JWTDecode;
|
||||
74
src/core/operations/JWTSign.mjs
Normal file
74
src/core/operations/JWTSign.mjs
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
/**
|
||||
* @author gchq77703 []
|
||||
* @copyright Crown Copyright 2018
|
||||
* @license Apache-2.0
|
||||
*/
|
||||
|
||||
import Operation from "../Operation";
|
||||
import jwt from "jsonwebtoken";
|
||||
import OperationError from "../errors/OperationError";
|
||||
|
||||
/**
|
||||
* JWT Sign operation
|
||||
*/
|
||||
class JWTSign extends Operation {
|
||||
|
||||
/**
|
||||
* JWTSign constructor
|
||||
*/
|
||||
constructor() {
|
||||
super();
|
||||
|
||||
this.name = "JWT Sign";
|
||||
this.module = "Crypto";
|
||||
this.description = "Signs a JSON object as a JSON Web Token using a provided secret / private key.<br><br>The key should be either the secret for HMAC algorithms or the PEM-encoded private key for RSA and ECDSA.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/JSON_Web_Token";
|
||||
this.inputType = "JSON";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
{
|
||||
name: "Private/Secret Key",
|
||||
type: "text",
|
||||
value: "secret"
|
||||
},
|
||||
{
|
||||
name: "Signing algorithm",
|
||||
type: "option",
|
||||
value: [
|
||||
"HS256",
|
||||
"HS384",
|
||||
"HS512",
|
||||
"RS256",
|
||||
"RS384",
|
||||
"RS512",
|
||||
"ES256",
|
||||
"ES384",
|
||||
"ES512",
|
||||
"None"
|
||||
]
|
||||
}
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {JSON} input
|
||||
* @param {Object[]} args
|
||||
* @returns {string}
|
||||
*/
|
||||
run(input, args) {
|
||||
const [key, algorithm] = args;
|
||||
|
||||
try {
|
||||
return jwt.sign(input, key, {
|
||||
algorithm: algorithm === "None" ? "none" : algorithm
|
||||
});
|
||||
} catch (err) {
|
||||
throw new OperationError(`Error: Have you entered the key correctly? The key should be either the secret for HMAC algorithms or the PEM-encoded private key for RSA and ECDSA.
|
||||
|
||||
${err}`);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
export default JWTSign;
|
||||
65
src/core/operations/JWTVerify.mjs
Normal file
65
src/core/operations/JWTVerify.mjs
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
/**
|
||||
* @author gchq77703 []
|
||||
* @copyright Crown Copyright 2018
|
||||
* @license Apache-2.0
|
||||
*/
|
||||
|
||||
import Operation from "../Operation";
|
||||
import jwt from "jsonwebtoken";
|
||||
import OperationError from "../errors/OperationError";
|
||||
|
||||
/**
|
||||
* JWT Verify operation
|
||||
*/
|
||||
class JWTVerify extends Operation {
|
||||
|
||||
/**
|
||||
* JWTVerify constructor
|
||||
*/
|
||||
constructor() {
|
||||
super();
|
||||
|
||||
this.name = "JWT Verify";
|
||||
this.module = "Crypto";
|
||||
this.description = "Verifies that a JSON Web Token is valid and has been signed with the provided secret / private key.<br><br>The key should be either the secret for HMAC algorithms or the PEM-encoded private key for RSA and ECDSA.";
|
||||
this.infoURL = "https://wikipedia.org/wiki/JSON_Web_Token";
|
||||
this.inputType = "string";
|
||||
this.outputType = "JSON";
|
||||
this.args = [
|
||||
{
|
||||
name: "Private/Secret Key",
|
||||
type: "text",
|
||||
value: "secret"
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} input
|
||||
* @param {Object[]} args
|
||||
* @returns {string}
|
||||
*/
|
||||
run(input, args) {
|
||||
const [key] = args;
|
||||
|
||||
try {
|
||||
const verified = jwt.verify(input, key, { algorithms: [
|
||||
"HS256",
|
||||
"HS384",
|
||||
"HS512",
|
||||
"none"
|
||||
]});
|
||||
|
||||
if (verified.hasOwnProperty("name") && verified.name === "JsonWebTokenError") {
|
||||
throw new OperationError(verified.message);
|
||||
}
|
||||
|
||||
return verified;
|
||||
} catch (err) {
|
||||
throw new OperationError(err);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
export default JWTVerify;
|
||||
|
|
@ -21,6 +21,7 @@ class JavaScriptParser extends Operation {
|
|||
this.name = "JavaScript Parser";
|
||||
this.module = "Code";
|
||||
this.description = "Returns an Abstract Syntax Tree for valid JavaScript code.";
|
||||
this.infoURL = "https://en.wikipedia.org/wiki/Abstract_syntax_tree";
|
||||
this.inputType = "string";
|
||||
this.outputType = "string";
|
||||
this.args = [
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue