mirror of
https://github.com/gchq/CyberChef.git
synced 2024-09-06 11:41:35 +02:00
215 lines
5.7 KiB
JavaScript
Executable File
215 lines
5.7 KiB
JavaScript
Executable File
import Utils from "../Utils.js";
|
|
|
|
|
|
/**
|
|
* Binary-Coded Decimal operations.
|
|
*
|
|
* @author n1474335 [n1474335@gmail.com]
|
|
* @copyright Crown Copyright 2017
|
|
* @license Apache-2.0
|
|
*
|
|
* @namespace
|
|
*/
|
|
const BCD = {
|
|
|
|
/**
|
|
* @constant
|
|
* @default
|
|
*/
|
|
ENCODING_SCHEME: [
|
|
"8 4 2 1",
|
|
"7 4 2 1",
|
|
"4 2 2 1",
|
|
"2 4 2 1",
|
|
"8 4 -2 -1",
|
|
"Excess-3",
|
|
"IBM 8 4 2 1",
|
|
],
|
|
|
|
/**
|
|
* Lookup table for the binary value of each digit representation.
|
|
*
|
|
* I wrote a very nice algorithm to generate 8 4 2 1 encoding programatically,
|
|
* but unfortunately it's much easier (if less elegant) to use lookup tables
|
|
* when supporting multiple encoding schemes.
|
|
*
|
|
* "Practicality beats purity" - PEP 20
|
|
*
|
|
* In some schemes it is possible to represent the same value in multiple ways.
|
|
* For instance, in 4 2 2 1 encoding, 0100 and 0010 both represent 2. Support
|
|
* has not yet been added for this.
|
|
*
|
|
* @constant
|
|
*/
|
|
ENCODING_LOOKUP: {
|
|
"8 4 2 1": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
|
|
"7 4 2 1": [0, 1, 2, 3, 4, 5, 6, 8, 9, 10],
|
|
"4 2 2 1": [0, 1, 4, 5, 8, 9, 12, 13, 14, 15],
|
|
"2 4 2 1": [0, 1, 2, 3, 4, 11, 12, 13, 14, 15],
|
|
"8 4 -2 -1": [0, 7, 6, 5, 4, 11, 10, 9, 8, 15],
|
|
"Excess-3": [3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
|
|
"IBM 8 4 2 1": [10, 1, 2, 3, 4, 5, 6, 7, 8, 9],
|
|
},
|
|
|
|
/**
|
|
* @default
|
|
* @constant
|
|
*/
|
|
FORMAT: ["Nibbles", "Bytes", "Raw"],
|
|
|
|
|
|
/**
|
|
* To BCD operation.
|
|
*
|
|
* @param {number} input
|
|
* @param {Object[]} args
|
|
* @returns {string}
|
|
*/
|
|
runToBCD: function(input, args) {
|
|
if (isNaN(input))
|
|
return "Invalid input";
|
|
if (Math.floor(input) !== input)
|
|
return "Fractional values are not supported by BCD";
|
|
|
|
const encoding = BCD.ENCODING_LOOKUP[args[0]],
|
|
packed = args[1],
|
|
signed = args[2],
|
|
outputFormat = args[3];
|
|
|
|
// Split input number up into separate digits
|
|
const digits = input.toString().split("");
|
|
|
|
if (digits[0] === "-" || digits[0] === "+") {
|
|
digits.shift();
|
|
}
|
|
|
|
let nibbles = [];
|
|
|
|
digits.forEach(d => {
|
|
const n = parseInt(d, 10);
|
|
nibbles.push(encoding[n]);
|
|
});
|
|
|
|
if (signed) {
|
|
if (packed && digits.length % 2 === 0) {
|
|
// If there are an even number of digits, we add a leading 0 so
|
|
// that the sign nibble doesn't sit in its own byte, leading to
|
|
// ambiguity around whether the number ends with a 0 or not.
|
|
nibbles.unshift(encoding[0]);
|
|
}
|
|
|
|
nibbles.push(input > 0 ? 12 : 13);
|
|
// 12 ("C") for + (credit)
|
|
// 13 ("D") for - (debit)
|
|
}
|
|
|
|
let bytes = [];
|
|
|
|
if (packed) {
|
|
let encoded = 0,
|
|
little = false;
|
|
|
|
nibbles.forEach(n => {
|
|
encoded ^= little ? n : (n << 4);
|
|
if (little) {
|
|
bytes.push(encoded);
|
|
encoded = 0;
|
|
}
|
|
little = !little;
|
|
});
|
|
|
|
if (little) bytes.push(encoded);
|
|
} else {
|
|
bytes = nibbles;
|
|
|
|
// Add null high nibbles
|
|
nibbles = nibbles.map(n => {
|
|
return [0, n];
|
|
}).reduce((a, b) => {
|
|
return a.concat(b);
|
|
});
|
|
}
|
|
|
|
// Output
|
|
switch (outputFormat) {
|
|
case "Nibbles":
|
|
return nibbles.map(n => {
|
|
return Utils.padLeft(n.toString(2), 4);
|
|
}).join(" ");
|
|
case "Bytes":
|
|
return bytes.map(b => {
|
|
return Utils.padLeft(b.toString(2), 8);
|
|
}).join(" ");
|
|
case "Raw":
|
|
default:
|
|
return Utils.byteArrayToChars(bytes);
|
|
}
|
|
},
|
|
|
|
|
|
/**
|
|
* From BCD operation.
|
|
*
|
|
* @param {string} input
|
|
* @param {Object[]} args
|
|
* @returns {number}
|
|
*/
|
|
runFromBCD: function(input, args) {
|
|
const encoding = BCD.ENCODING_LOOKUP[args[0]],
|
|
packed = args[1],
|
|
signed = args[2],
|
|
inputFormat = args[3];
|
|
|
|
let nibbles = [],
|
|
output = "",
|
|
byteArray;
|
|
|
|
// Normalise the input
|
|
switch (inputFormat) {
|
|
case "Nibbles":
|
|
case "Bytes":
|
|
input = input.replace(/\s/g, "");
|
|
for (let i = 0; i < input.length; i += 4) {
|
|
nibbles.push(parseInt(input.substr(i, 4), 2));
|
|
}
|
|
break;
|
|
case "Raw":
|
|
default:
|
|
byteArray = Utils.strToByteArray(input);
|
|
byteArray.forEach(b => {
|
|
nibbles.push(b >>> 4);
|
|
nibbles.push(b & 15);
|
|
});
|
|
break;
|
|
}
|
|
|
|
if (!packed) {
|
|
// Discard each high nibble
|
|
for (let i = 0; i < nibbles.length; i++) {
|
|
nibbles.splice(i, 1);
|
|
}
|
|
}
|
|
|
|
if (signed) {
|
|
const sign = nibbles.pop();
|
|
if (sign === 13 ||
|
|
sign === 11) {
|
|
// Negative
|
|
output += "-";
|
|
}
|
|
}
|
|
|
|
nibbles.forEach(n => {
|
|
if (isNaN(n)) throw "Invalid input";
|
|
let val = encoding.indexOf(n);
|
|
if (val < 0) throw `Value ${Utils.bin(n, 4)} not in encoding scheme`;
|
|
output += val.toString();
|
|
});
|
|
|
|
return parseInt(output, 10);
|
|
},
|
|
|
|
};
|
|
|
|
export default BCD;
|