Add Salsa20 and XSalsa20 operation

src/core/lib/Salsa20.mjs

@@ -0,0 +1,144 @@
+/**
+ * @author joostrijneveld [joost@joostrijneveld.nl]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Utils from "../Utils.mjs";
+
+/**
+ * Computes the Salsa20 permute function
+ *
+ * @param {byteArray} x
+ * @param {integer} rounds
+ */
+function salsa20Permute(x, rounds) {
+    /**
+     * Macro to compute a 32-bit rotate-left operation
+     *
+     * @param {integer} x
+     * @param {integer} n
+     * @returns {integer}
+     */
+    function ROL32(x, n) {
+        return ((x << n) & 0xFFFFFFFF) | (x >>> (32 - n));
+    }
+
+    /**
+     * Macro to compute a single Salsa20 quarterround operation
+     *
+     * @param {integer} x
+     * @param {integer} a
+     * @param {integer} b
+     * @param {integer} c
+     * @param {integer} d
+     * @returns {integer}
+     */
+    function quarterround(x, a, b, c, d) {
+        x[b] ^= ROL32((x[a] + x[d]) & 0xFFFFFFFF, 7);
+        x[c] ^= ROL32((x[b] + x[a]) & 0xFFFFFFFF, 9);
+        x[d] ^= ROL32((x[c] + x[b]) & 0xFFFFFFFF, 13);
+        x[a] ^= ROL32((x[d] + x[c]) & 0xFFFFFFFF, 18);
+    }
+
+    for (let i = 0; i < rounds / 2; i++)  {
+        quarterround(x, 0, 4, 8, 12);
+        quarterround(x, 5, 9, 13, 1);
+        quarterround(x, 10, 14, 2, 6);
+        quarterround(x, 15, 3, 7, 11);
+        quarterround(x, 0, 1, 2, 3);
+        quarterround(x, 5, 6, 7, 4);
+        quarterround(x, 10, 11, 8, 9);
+        quarterround(x, 15, 12, 13, 14);
+    }
+}
+
+/**
+ * Computes the Salsa20 block function
+ *
+ * @param {byteArray} key
+ * @param {byteArray} nonce
+ * @param {byteArray} counter
+ * @param {integer} rounds
+ * @returns {byteArray}
+ */
+export function salsa20Block(key, nonce, counter, rounds) {
+    const tau = "expand 16-byte k";
+    const sigma = "expand 32-byte k";
+    let state, c;
+    if (key.length === 16) {
+        c = Utils.strToByteArray(tau);
+        key = key.concat(key);
+    } else {
+        c = Utils.strToByteArray(sigma);
+    }
+
+    state = c.slice(0, 4);
+    state = state.concat(key.slice(0, 16));
+    state = state.concat(c.slice(4, 8));
+    state = state.concat(nonce);
+    state = state.concat(counter);
+    state = state.concat(c.slice(8, 12));
+    state = state.concat(key.slice(16, 32));
+    state = state.concat(c.slice(12, 16));
+
+    const x = Array();
+    for (let i = 0; i < 64; i += 4) {
+        x.push(Utils.byteArrayToInt(state.slice(i, i + 4), "little"));
+    }
+    const a = [...x];
+
+    salsa20Permute(x, rounds);
+
+    for (let i = 0; i < 16; i++) {
+        x[i] = (x[i] + a[i]) & 0xFFFFFFFF;
+    }
+
+    let output = Array();
+    for (let i = 0; i < 16; i++) {
+        output = output.concat(Utils.intToByteArray(x[i], 4, "little"));
+    }
+    return output;
+}
+
+/**
+ * Computes the hSalsa20 function
+ *
+ * @param {byteArray} key
+ * @param {byteArray} nonce
+ * @param {integer} rounds
+ * @returns {byteArray}
+ */
+export function hsalsa20(key, nonce, rounds) {
+    const tau = "expand 16-byte k";
+    const sigma = "expand 32-byte k";
+    let state, c;
+    if (key.length === 16) {
+        c = Utils.strToByteArray(tau);
+        key = key.concat(key);
+    } else {
+        c = Utils.strToByteArray(sigma);
+    }
+
+    state = c.slice(0, 4);
+    state = state.concat(key.slice(0, 16));
+    state = state.concat(c.slice(4, 8));
+    state = state.concat(nonce);
+    state = state.concat(c.slice(8, 12));
+    state = state.concat(key.slice(16, 32));
+    state = state.concat(c.slice(12, 16));
+
+    const x = Array();
+    for (let i = 0; i < 64; i += 4) {
+        x.push(Utils.byteArrayToInt(state.slice(i, i + 4), "little"));
+    }
+
+    salsa20Permute(x, rounds);
+
+    let output = Array();
+    const idx = [0, 5, 10, 15, 6, 7, 8, 9];
+    for (let i = 0; i < 8; i++) {
+        output = output.concat(Utils.intToByteArray(x[idx[i]], 4, "little"));
+    }
+    return output;
+}