feat: add sha384, sha512 support (#282)

Signed-off-by: Lukas.J Han <[email protected]>
Signed-off-by: Lukas J Han <[email protected]>
Signed-off-by: Lukas.J.Han <[email protected]>
Signed-off-by: Mirko Mollik <[email protected]>
Co-authored-by: Mirko Mollik <[email protected]>

Author: lukasjhan

packages/hash/package.json

@@ -41,7 +41,7 @@
     "@sd-jwt/crypto-nodejs": "workspace:*"
   },
   "dependencies": {
-    "@noble/hashes": "1.0.0",
+    "@noble/hashes": "^1.8.0",
     "@sd-jwt/utils": "workspace:*"
   },
   "publishConfig": {

packages/hash/src/index.ts

@@ -1 +1 @@
-export * from './sha256';
+export * from './sha';

packages/hash/src/sha.ts

@@ -0,0 +1,89 @@
+import {
+  sha256 as nobleSha256,
+  sha384 as nobleSha384,
+  sha512 as nobleSha512,
+} from '@noble/hashes/sha2.js';
+import { SDJWTException } from '@sd-jwt/utils';
+
+export const sha256 = (text: string | ArrayBuffer): Uint8Array => {
+  const uint8Array =
+    typeof text === 'string' ? toUTF8Array(text) : new Uint8Array(text);
+  const hashBytes = nobleSha256(uint8Array);
+  return hashBytes;
+};
+
+export const sha384 = (text: string | ArrayBuffer): Uint8Array => {
+  const uint8Array =
+    typeof text === 'string' ? toUTF8Array(text) : new Uint8Array(text);
+  const hashBytes = nobleSha384(uint8Array);
+  return hashBytes;
+};
+
+export const sha512 = (text: string | ArrayBuffer): Uint8Array => {
+  const uint8Array =
+    typeof text === 'string' ? toUTF8Array(text) : new Uint8Array(text);
+  const hashBytes = nobleSha512(uint8Array);
+  return hashBytes;
+};
+
+type HasherAlgorithm = 'sha256' | 'sha384' | 'sha512' | (string & {});
+
+export const hasher = (
+  data: string | ArrayBuffer,
+  algorithm: HasherAlgorithm = 'sha256',
+) => {
+  const msg =
+    typeof data === 'string' ? toUTF8Array(data) : new Uint8Array(data);
+
+  const alg = toCryptoAlg(algorithm);
+
+  switch (alg) {
+    case 'sha256':
+      return sha256(msg);
+    case 'sha384':
+      return sha384(msg);
+    case 'sha512':
+      return sha512(msg);
+    default:
+      throw new SDJWTException(`Unsupported algorithm: ${algorithm}`);
+  }
+};
+
+const toCryptoAlg = (hashAlg: HasherAlgorithm): string =>
+  // To cover sha-256, sha256, SHA-256, SHA256
+  hashAlg
+    .replace('-', '')
+    .toLowerCase();
+
+function toUTF8Array(str: string) {
+  const utf8: Array<number> = [];
+  for (let i = 0; i < str.length; i++) {
+    let charcode = str.charCodeAt(i);
+    if (charcode < 0x80) utf8.push(charcode);
+    else if (charcode < 0x800) {
+      utf8.push(0xc0 | (charcode >> 6), 0x80 | (charcode & 0x3f));
+    } else if (charcode < 0xd800 || charcode >= 0xe000) {
+      utf8.push(
+        0xe0 | (charcode >> 12),
+        0x80 | ((charcode >> 6) & 0x3f),
+        0x80 | (charcode & 0x3f),
+      );
+    }
+    // surrogate pair
+    else {
+      i++;
+      // UTF-16 encodes 0x10000-0x10FFFF by
+      // subtracting 0x10000 and splitting the
+      // 20 bits of 0x0-0xFFFFF into two halves
+      charcode =
+        0x10000 + (((charcode & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
+      utf8.push(
+        0xf0 | (charcode >> 18),
+        0x80 | ((charcode >> 12) & 0x3f),
+        0x80 | ((charcode >> 6) & 0x3f),
+        0x80 | (charcode & 0x3f),
+      );
+    }
+  }
+  return new Uint8Array(utf8);
+}

packages/hash/src/sha256.ts

@@ -2,8 +2,9 @@ import { digest } from '@sd-jwt/crypto-nodejs';
 import { bytesToHex } from '@noble/hashes/utils';
 import { hasher, sha256 } from '../index';
 import { describe, expect, test } from 'vitest';
+import { createHash } from 'node:crypto';
 
-describe('SHA-256 tests', () => {
+describe('hashing tests', () => {
   test('test#1', async () => {
     const payload = 'test1';
     const s1 = bytesToHex(await digest(payload));
@@ -123,4 +124,66 @@ describe('SHA-256 tests', () => {
       expect(e).toBeInstanceOf(Error);
     }
   });
+
+  describe('Hash', () => {
+    (process.env.npm_lifecycle_event === 'test:browser' ? test.skip : test)(
+      'sha256 - string',
+      () => {
+        const data = 'test';
+        const hashdata = hasher(data, 'sha-256');
+        const hashdata2 = createHash('sha256').update(data).digest();
+        expect(bytesToHex(hashdata)).toEqual(bytesToHex(hashdata2));
+      },
+    );
+
+    (process.env.npm_lifecycle_event === 'test:browser' ? test.skip : test)(
+      'sha256 - arraybuffer',
+      () => {
+        const data = new TextEncoder().encode('test');
+        const hashdata = hasher(data, 'sha-256');
+        const hashdata2 = createHash('sha256').update(data).digest();
+        expect(bytesToHex(hashdata)).toEqual(bytesToHex(hashdata2));
+      },
+    );
+
+    (process.env.npm_lifecycle_event === 'test:browser' ? test.skip : test)(
+      'sha-384 - string',
+      () => {
+        const data = 'test';
+        const hashdata = hasher(data, 'sha-384');
+        const hashdata2 = createHash('sha384').update(data).digest();
+        expect(bytesToHex(hashdata)).toEqual(bytesToHex(hashdata2));
+      },
+    );
+
+    (process.env.npm_lifecycle_event === 'test:browser' ? test.skip : test)(
+      'sha-384 - arraybuffer',
+      () => {
+        const data = new TextEncoder().encode('test');
+        const hashdata = hasher(data, 'sha-384');
+        const hashdata2 = createHash('sha384').update(data).digest();
+        expect(bytesToHex(hashdata)).toEqual(bytesToHex(hashdata2));
+      },
+    );
+
+    (process.env.npm_lifecycle_event === 'test:browser' ? test.skip : test)(
+      'sha-512 - string',
+      () => {
+        const data = 'test';
+        const hashdata = hasher(data, 'sha-512');
+        const hashdata2 = createHash('sha512').update(data).digest();
+        expect(bytesToHex(hashdata)).toEqual(bytesToHex(hashdata2));
+      },
+    );
+
+    (process.env.npm_lifecycle_event === 'test:browser' ? test.skip : test)(
+      'sha-512 - arraybuffer',
+      () => {
+        const data = new TextEncoder().encode('test');
+        const hashdata = hasher(data, 'sha-512');
+        const hashdata2 = createHash('sha512').update(data).digest();
+        expect(bytesToHex(hashdata)).toEqual(bytesToHex(hashdata2));
+      },
+    );
+  });
 });