mirrors/CyberChef
1
0
Fork 0
mirror of https://github.com/gchq/CyberChef.git synced 2025-04-24 00:36:16 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Additional linter corrections

Browse source
This commit is contained in:
Dan Flack 2024-09-21 12:00:37 +02:00
parent 0f16fa0ce1
commit f61bdf06c6
4 changed files with 74 additions and 83 deletions
Download patch file Download diff file Expand all files Collapse all files

104
src/core/lib/SM2.mjs
View file

@ -19,8 +19,8 @@ export class SM2 {
/**
* Constructor for SM2 class; sets up with the curve and the output format as specified in user args
*
* @param {*} curve
* @param {*} format
* @param {*} curve
* @param {*} format
*/
constructor(curve, format) {
this.ecParams = null;
@ -39,7 +39,7 @@ export class SM2 {
"32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7", // gx
"BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0", // gy
[]
) // alias
); // alias
this.ecParams = r.crypto.ECParameterDB.getByName(curve);
this.format = format;
@ -79,15 +79,15 @@ export class SM2 {
* @returns {string}
*/
encrypt(input) {
const G = this.ecParams.G
const G = this.ecParams.G;
/*
* Compute a new, random public key along the same elliptic curve to form the starting point for our encryption process (record the resulting X and Y as hex to provide as part of the operation output)
* k: Randomly generated BigInteger
* c1: Result of dotting our curve generator point `G` with the value of `k`
*/
var k = this.generatePublicKey();
var c1 = G.multiply(k);
const k = this.generatePublicKey();
const c1 = G.multiply(k);
const [hexC1X, hexC1Y] = this.getPointAsHex(c1);
/*
@ -98,21 +98,21 @@ export class SM2 {
/*
* Compute the C3 SM3 hash before we transform the array
*/
var c3 = this.c3(p2, input);
const c3 = this.c3(p2, input);
/*
* Genreate a proper length encryption key, XOR iteratively, and convert newly encrypted data to hex
*/
var key = this.kdf(p2, input.byteLength);
const key = this.kdf(p2, input.byteLength);
for (let i = 0; i < input.byteLength; i++) {
input[i] ^= Utils.ord(key[i]);
}
var c2 = Buffer.from(input).toString('hex');
const c2 = Buffer.from(input).toString("hex");
/*
* Check user input specs; order the output components as selected
*/
if (this.format == "C1C3C2") {
if (this.format === "C1C3C2") {
return hexC1X + hexC1Y + c3 + c2;
} else {
return hexC1X + hexC1Y + c2 + c3;
@ -124,37 +124,37 @@ export class SM2 {
* @param {*} input
*/
decrypt(input) {
var c1X = input.slice(0, 64);
var c1Y = input.slice(64, 128);
const c1X = input.slice(0, 64);
const c1Y = input.slice(64, 128);
var c3 = ""
var c2 = ""
let c3 = "";
let c2 = "";
if (this.format == "C1C3C2") {
c3 = input.slice(128,192);
if (this.format === "C1C3C2") {
c3 = input.slice(128, 192);
c2 = input.slice(192);
} else {
c2 = input.slice(128, -64);
c3 = input.slice(-64);
}
c2 = Uint8Array.from(fromHex(c2))
var c1 = this.ecParams.curve.decodePointHex("04" + c1X + c1Y);
c2 = Uint8Array.from(fromHex(c2));
const c1 = this.ecParams.curve.decodePointHex("04" + c1X + c1Y);
/*
* Compute the p2 (secret) value by taking the C1 point provided in the encrypted package, and multiplying by the private k value
*/
var p2 = c1.multiply(this.privateKey);
const p2 = c1.multiply(this.privateKey);
/*
* Similar to encryption; compute sufficient length key material and XOR the input data to recover the original message
*/
var key = this.kdf(p2, c2.byteLength);
const key = this.kdf(p2, c2.byteLength);
for (let i = 0; i < c2.byteLength; i++) {
c2[i] ^= Utils.ord(key[i]);
}
var check = this.c3(p2, c2);
const check = this.c3(p2, c2);
if (check === c3) {
return c2.buffer;
} else {
@ -165,9 +165,9 @@ export class SM2 {
/**
* Generates a large random number
*
* @param {*} limit
* @returns
*
* @param {*} limit
* @returns
*/
getBigRandom(limit) {
return new r.BigInteger(limit.bitLength(), this.rng)
@ -177,51 +177,51 @@ export class SM2 {
/**
* Helper function for generating a large random K number; utilized for generating our initial C1 point
* TODO: Do we need to do any sort of validation on the resulting k values?
*
* TODO: Do we need to do any sort of validation on the resulting k values?
*
* @returns {BigInteger}
*/
generatePublicKey() {
const n = this.ecParams.n;
var k = this.getBigRandom(n);
const k = this.getBigRandom(n);
return k;
}
/**
* SM2 Key Derivation Function (KDF); Takes P2 point, and generates a key material stream large enough to encrypt all of the input data
*
* @param {*} p2
* @param {*} len
*
* @param {*} p2
* @param {*} len
* @returns {string}
*/
kdf(p2, len) {
const [hX, hY] = this.getPointAsHex(p2);
var total = Math.ceil(len / 32) + 1;
var cnt = 1;
const total = Math.ceil(len / 32) + 1;
let cnt = 1;
var keyMaterial = ""
let keyMaterial = "";
while (cnt < total) {
var num = Utils.intToByteArray(cnt, 4, "big");
var overall = fromHex(hX).concat(fromHex(hY)).concat(num)
const num = Utils.intToByteArray(cnt, 4, "big");
const overall = fromHex(hX).concat(fromHex(hY)).concat(num);
keyMaterial += this.sm3(overall);
cnt++;
}
return keyMaterial
return keyMaterial;
}
/**
* Calculates the C3 component of our final encrypted payload; which is the SM3 hash of the P2 point and the original, unencrypted input data
*
* @param {*} p2
* @param {*} input
* @returns {string}
*
* @param {*} p2
* @param {*} input
* @returns {string}
*/
c3(p2, input) {
const [hX, hY] = this.getPointAsHex(p2);
var overall = fromHex(hX).concat(Array.from(input)).concat(fromHex(hY));
const overall = fromHex(hX).concat(Array.from(input)).concat(fromHex(hY));
return toHex(this.sm3(overall));
@ -229,12 +229,12 @@ export class SM2 {
/**
* SM3 setup helper function; takes input data as an array, processes the hash and returns the result
*
* @param {*} data
*
* @param {*} data
* @returns {string}
*/
sm3(data) {
var hashData = Utils.arrayBufferToStr(Uint8Array.from(data).buffer, false);
const hashData = Utils.arrayBufferToStr(Uint8Array.from(data).buffer, false);
const hasher = new Sm3();
hasher.update(hashData);
return hasher.finalize();
@ -242,17 +242,17 @@ export class SM2 {
/**
* Utility function, returns an elliptic curve points X and Y values as hex;
*
*
* @param {EcPointFp} point
* @returns {[]}
*/
getPointAsHex(point) {
var biX = point.getX().toBigInteger();
var biY = point.getY().toBigInteger();
const biX = point.getX().toBigInteger();
const biY = point.getY().toBigInteger();
var charlen = this.ecParams.keycharlen;
var hX = ("0000000000" + biX.toString(16)).slice(- charlen);
var hY = ("0000000000" + biY.toString(16)).slice(- charlen);
return [hX, hY]
const charlen = this.ecParams.keycharlen;
const hX = ("0000000000" + biX.toString(16)).slice(- charlen);
const hY = ("0000000000" + biY.toString(16)).slice(- charlen);
return [hX, hY];
}
}
}

8
src/core/operations/SM2Decrypt.mjs
View file

@ -5,7 +5,6 @@
*/
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
import { SM2 } from "../lib/SM2.mjs";
@ -55,12 +54,11 @@ class SM2Decrypt extends Operation {
run(input, args) {
const [privateKey, inputFormat, curveName] = args;
var sm2 = new SM2(curveName, inputFormat);
const sm2 = new SM2(curveName, inputFormat);
sm2.setPrivateKey(privateKey);
var result = sm2.decrypt(input);
return result
const result = sm2.decrypt(input);
return result;
}
}

23
src/core/operations/SM2Encrypt.mjs
View file

@ -5,16 +5,9 @@
*/
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
import { SM2 } from "../lib/SM2.mjs";
import { fromHex } from "../lib/Hex.mjs";
import Utils from "../Utils.mjs";
import Sm3 from "crypto-api/src/hasher/sm3.mjs";
import {toHex} from "crypto-api/src/encoder/hex.mjs";
import r from "jsrsasign";
/**
* SM2 Encrypt operation
*/
@ -68,11 +61,11 @@ class SM2Encrypt extends Operation {
const [publicKeyX, publicKeyY, outputFormat, curveName] = args;
this.outputFormat = outputFormat;
var sm2 = new SM2(curveName, outputFormat);
const sm2 = new SM2(curveName, outputFormat);
sm2.setPublicKey(publicKeyX, publicKeyY);
var result = sm2.encrypt(new Uint8Array(input))
return result
const result = sm2.encrypt(new Uint8Array(input));
return result;
}
/**
@ -85,11 +78,11 @@ class SM2Encrypt extends Operation {
* @returns {Object[]} pos
*/
highlight(pos, args) {
const [privateKeyX, privateKeyY, outputFormat, curveName] = args;
var num = pos[0].end - pos[0].start
var adjust = 128
if (outputFormat == "C1C3C2") {
adjust = 192
const outputFormat = args[2];
const num = pos[0].end - pos[0].start;
let adjust = 128;
if (outputFormat === "C1C3C2") {
adjust = 192;
}
pos[0].start = Math.ceil(pos[0].start + adjust);
pos[0].end = Math.floor(pos[0].end + adjust + num);