🚧 progress: Import existing code.

Author: make-github-pseudonymous-again

package.json

@@ -68,17 +68,22 @@
     "test:module": "IMPORT_MAP_PATH=test/import-maps/dist/index.module.json npm run test-cmd",
     "test:src": "IMPORT_MAP_PATH=test/import-maps/src/index.json npm run test-cmd"
   },
-  "dependencies": {},
+  "dependencies": {
+    "@arithmetic-type/uint32": "^2.0.0"
+  },
   "devDependencies": {
+    "@array-like/alloc": "0.0.1",
     "@babel/core": "7.19.0",
     "@babel/plugin-transform-destructuring": "7.18.13",
     "@babel/plugin-transform-for-of": "7.18.8",
     "@babel/preset-env": "7.19.0",
+    "@codec-bytes/ascii": "3.0.0",
     "@commitlint/cli": "17.1.2",
     "@js-library/commitlint-config": "0.0.4",
     "@node-loader/babel": "2.0.1",
     "@node-loader/core": "2.0.0",
     "@node-loader/import-maps": "1.1.0",
+    "@set-theory/cartesian-product": "2.0.2",
     "ava": "4.3.3",
     "babel-plugin-transform-remove-console": "6.9.4",
     "babel-plugin-unassert": "3.2.0",
@@ -225,6 +230,15 @@
           "doc/**"
         ],
         "env": "browser"
+      },
+      {
+        "files": [
+          "src/**"
+        ],
+        "rules": {
+          "no-bitwise": "off",
+          "unicorn/prefer-math-trunc": "off"
+        }
       }
     ]
   }

src/index.js

@@ -1,2 +1 @@
-const answer = 42;
-export default answer;
+export * from './sha1.js';

src/sha1.js

@@ -0,0 +1,198 @@
+import {get32, big32, rotl32, add32} from '@arithmetic-type/uint32';
+
+function cycle(h, w) {
+	// Initialize hash value for this chunk:
+	let a = h[0];
+	let b = h[1];
+	let c = h[2];
+	let d = h[3];
+	let e = h[4]; // eslint-disable-line unicorn/prevent-abbreviations
+
+	// Main loop:[35]
+	// for j from 0 to 79
+	for (let j = 0; j < 80; ++j) {
+		let f;
+		let k;
+
+		// If 0 ≤ j ≤ 19 then
+		if (j >= 0 && j <= 19) {
+			// F = (b and c) or ((not b) and d)
+			f = (b & c) | (~b & d);
+			k = 1_518_500_249; // 0x5A827999
+		}
+		// Else if 20 ≤ j ≤ 39
+		else if (j >= 20 && j <= 39) {
+			// F = b xor c xor d
+			f = b ^ c ^ d;
+			k = 1_859_775_393; // 0x6ED9EBA1
+		}
+		// Else if 40 ≤ j ≤ 59
+		else if (j >= 40 && j <= 59) {
+			// F = (b and c) or (b and d) or (c and d)
+			f = (b & c) | (b & d) | (c & d);
+			k = -1_894_007_588; // 0x8F1BBCDC
+		}
+		// Else if 60 ≤ j ≤ 79
+		else {
+			// F = b xor c xor d
+			f = b ^ c ^ d;
+			k = -899_497_514; // 0xCA62C1D6
+		}
+
+		// T = (a leftrotate 5) + f + e + k + w[j]
+		const t = add32(add32(rotl32(a, 5), f), add32(add32(e, k), w[j]));
+		e = d;
+		d = c;
+		// C = b leftrotate 30
+		c = rotl32(b, 30);
+		b = a;
+		a = t;
+	}
+
+	// Add this chunk's hash to result so far:
+	h[0] = add32(h[0], a);
+	h[1] = add32(h[1], b);
+	h[2] = add32(h[2], c);
+	h[3] = add32(h[3], d);
+	h[4] = add32(h[4], e);
+}
+
+function call(h, data, o) {
+	const w = Array.from({length: 80});
+
+	// Break chunk into sixteen 32-bit big-endian words w[i], 0 ≤ i ≤ 15
+	for (let j = 0; j < 16; ++j) {
+		w[j] = big32(data, o + j * 4);
+	}
+
+	// Extend the sixteen 32-bit words into eighty 32-bit words:
+	// for j from 16 to 79
+	for (let j = 16; j < 80; ++j) {
+		// W[j] = (w[j-3] xor w[j-8] xor w[j-14] xor w[j-16]) leftrotate 1
+		const k = w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16];
+		w[j] = rotl32(k, 1);
+	}
+
+	cycle(h, w);
+}
+
+/**
+ * SHA1
+ */
+export function sha1(bytes, n, digest) {
+	// PREPARE
+
+	const q = (n / 8) | 0;
+	const z = q * 8;
+	const u = n - z;
+
+	// Append the bit '1' to the message
+	const last = u > 0 ? bytes[q] & (~0 << (7 - u)) : 0x80;
+
+	// Note 1: All variables are unsigned 32 bits and wrap modulo 2^32 when calculating
+	// Note 2: All constants in this pseudo code are in big endian.
+	// Within each word, the most significant byte is stored in the leftmost byte position
+
+	// Initialize state:
+	const h = [
+		get32(0x67_45_23_01),
+		get32(0xef_cd_ab_89),
+		get32(0x98_ba_dc_fe),
+		get32(0x10_32_54_76),
+		get32(0xc3_d2_e1_f0),
+	];
+
+	// Process the message in successive 512-bit chunks:
+	// break message into 512-bit chunks
+
+	const m = (n / 512) | 0;
+	const y = ((n - 512 * m) / 8) | 0;
+
+	// Offset in data
+	let o = 0;
+
+	// For each chunk
+	for (let j = 0; j < m; ++j, o += 64) {
+		call(h, bytes, o);
+	}
+
+	// Last bytes + padding + length
+	let tail = [];
+
+	// Last bytes
+	for (let j = 0; j < y; ++j) {
+		tail.push(bytes[o + j]);
+	}
+
+	// Special care taken for the very last byte which could
+	// have been modified if n is not a multiple of 8
+	tail.push(last);
+
+	// Append 0 ≤ k < 512 bits '0', so that the resulting
+	// message length (in bits) is congruent to 448 (mod 512)
+	let zeroes = ((448 - ((n + 1) % 512)) / 8) | 0;
+
+	if (zeroes < 0) {
+		// We need an additional block as there is
+		// not enough space left to append
+		// the length of the data in bits
+
+		for (let j = 0; j < -zeroes; ++j) {
+			tail.push(0);
+		}
+
+		call(h, tail, 0);
+
+		zeroes = 448 / 8;
+		tail = [];
+	}
+
+	// Pad with zeroes
+	for (let j = 0; j < zeroes; ++j) {
+		tail.push(0);
+	}
+
+	// Append length of message (before preparation), in bits,
+	// as 64-bit big-endian integer
+
+	// JavaScript works with 32 bit integers.
+	// tail.push((n >>> 56) & 0xFF);
+	// tail.push((n >>> 48) & 0xFF);
+	// tail.push((n >>> 40) & 0xFF);
+	// tail.push((n >>> 32) & 0xFF);
+	tail.push(
+		0,
+		0,
+		0,
+		0,
+		(n >>> 24) & 0xff,
+		(n >>> 16) & 0xff,
+		(n >>> 8) & 0xff,
+		(n >>> 0) & 0xff,
+	);
+
+	call(h, tail, 0);
+
+	digest[0] = (h[0] >>> 24) & 0xff;
+	digest[1] = (h[0] >>> 16) & 0xff;
+	digest[2] = (h[0] >>> 8) & 0xff;
+	digest[3] = (h[0] >>> 0) & 0xff;
+	digest[4] = (h[1] >>> 24) & 0xff;
+	digest[5] = (h[1] >>> 16) & 0xff;
+	digest[6] = (h[1] >>> 8) & 0xff;
+	digest[7] = (h[1] >>> 0) & 0xff;
+	digest[8] = (h[2] >>> 24) & 0xff;
+	digest[9] = (h[2] >>> 16) & 0xff;
+	digest[10] = (h[2] >>> 8) & 0xff;
+	digest[11] = (h[2] >>> 0) & 0xff;
+	digest[12] = (h[3] >>> 24) & 0xff;
+	digest[13] = (h[3] >>> 16) & 0xff;
+	digest[14] = (h[3] >>> 8) & 0xff;
+	digest[15] = (h[3] >>> 0) & 0xff;
+	digest[16] = (h[4] >>> 24) & 0xff;
+	digest[17] = (h[4] >>> 16) & 0xff;
+	digest[18] = (h[4] >>> 8) & 0xff;
+	digest[19] = (h[4] >>> 0) & 0xff;
+
+	return digest;
+}

test/src/api.js

@@ -0,0 +1,83 @@
+import test from 'ava';
+import {alloc} from '@array-like/alloc';
+import {product} from '@set-theory/cartesian-product';
+import * as ascii from '@codec-bytes/ascii';
+
+import * as hash from '#module';
+
+function macro(t, [[sha1name, sha1], [string, expected]]) {
+	const digest = sha1(ascii.encode(string), string.length * 8, alloc(20));
+
+	t.deepEqual(digest, expected, `${sha1name} ${string}`);
+}
+
+macro.title = (title, [[f], [x, y]]) =>
+	title ?? `${f}(${JSON.stringify(x)}) == ${JSON.stringify(y)}`;
+
+const inputs = product(
+	[
+		[['sha1', hash.sha1]],
+
+		[
+			[
+				'The quick brown fox jumps over the lazy dog',
+				[
+					0x2f, 0xd4, 0xe1, 0xc6, 0x7a, 0x2d, 0x28, 0xfc, 0xed, 0x84, 0x9e,
+					0xe1, 0xbb, 0x76, 0xe7, 0x39, 0x1b, 0x93, 0xeb, 0x12,
+				],
+			],
+			[
+				'The quick brown fox jumps over the lazy cog',
+				[
+					0xde, 0x9f, 0x2c, 0x7f, 0xd2, 0x5e, 0x1b, 0x3a, 0xfa, 0xd3, 0xe8,
+					0x5a, 0x0b, 0xd1, 0x7d, 0x9b, 0x10, 0x0d, 0xb4, 0xb3,
+				],
+			],
+			[
+				'',
+				[
+					0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, 0x0d, 0x32, 0x55, 0xbf,
+					0xef, 0x95, 0x60, 0x18, 0x90, 0xaf, 0xd8, 0x07, 0x09,
+				],
+			],
+			[
+				'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.',
+				[
+					0xcd, 0x36, 0xb3, 0x70, 0x75, 0x8a, 0x25, 0x9b, 0x34, 0x84, 0x50,
+					0x84, 0xa6, 0xcc, 0x38, 0x47, 0x3c, 0xb9, 0x5e, 0x27,
+				],
+			],
+			[
+				'apple',
+				[
+					0xd0, 0xbe, 0x2d, 0xc4, 0x21, 0xbe, 0x4f, 0xcd, 0x01, 0x72, 0xe5,
+					0xaf, 0xce, 0xea, 0x39, 0x70, 0xe2, 0xf3, 0xd9, 0x40,
+				],
+			],
+			[
+				'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do',
+				[
+					0x69, 0x45, 0xdf, 0xee, 0x74, 0x11, 0xa3, 0x7b, 0x37, 0xcd, 0x6b,
+					0x0f, 0x47, 0xb0, 0xb2, 0x82, 0x64, 0x0d, 0xf1, 0x96,
+				],
+			],
+			[
+				'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do ',
+				[
+					0x15, 0xf5, 0xc9, 0x56, 0xef, 0x13, 0xd8, 0x6f, 0xaa, 0xf4, 0xd7,
+					0x44, 0xae, 0xd4, 0xb0, 0x6b, 0x11, 0x5f, 0x5b, 0x06,
+				],
+			],
+			[
+				'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do e',
+				[
+					0xe8, 0x79, 0x1d, 0xfb, 0x0c, 0xa2, 0x63, 0x71, 0x21, 0x4f, 0x62,
+					0x92, 0x01, 0x16, 0x43, 0x07, 0xd3, 0x13, 0x29, 0xe0,
+				],
+			],
+		],
+	],
+	1,
+);
+
+for (const x of inputs) test(macro, x);