@sd-jwt/hash 0.12.1-next.0 → 0.12.1-next.1

package/dist/index.d.mts

@@ -1,4 +1,7 @@
-declare const sha256: (text: string) => Uint8Array;
-declare const hasher: (data: string, algorithm: string) => Uint8Array;
+declare const sha256: (text: string | ArrayBuffer) => Uint8Array;
+declare const sha384: (text: string | ArrayBuffer) => Uint8Array;
+declare const sha512: (text: string | ArrayBuffer) => Uint8Array;
+type HasherAlgorithm = 'sha256' | 'sha384' | 'sha512' | (string & {});
+declare const hasher: (data: string | ArrayBuffer, algorithm?: HasherAlgorithm) => Uint8Array;
 
-export { hasher, sha256 };
+export { hasher, sha256, sha384, sha512 };

package/dist/index.d.ts

@@ -1,4 +1,7 @@
-declare const sha256: (text: string) => Uint8Array;
-declare const hasher: (data: string, algorithm: string) => Uint8Array;
+declare const sha256: (text: string | ArrayBuffer) => Uint8Array;
+declare const sha384: (text: string | ArrayBuffer) => Uint8Array;
+declare const sha512: (text: string | ArrayBuffer) => Uint8Array;
+type HasherAlgorithm = 'sha256' | 'sha384' | 'sha512' | (string & {});
+declare const hasher: (data: string | ArrayBuffer, algorithm?: HasherAlgorithm) => Uint8Array;
 
-export { hasher, sha256 };
+export { hasher, sha256, sha384, sha512 };

package/dist/index.js

@@ -21,23 +21,43 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   hasher: () => hasher,
-  sha256: () => sha256
+  sha256: () => sha256,
+  sha384: () => sha384,
+  sha512: () => sha512
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/sha256.ts
-var import_sha256 = require("@noble/hashes/sha256");
+// src/sha.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
 var import_utils = require("@sd-jwt/utils");
 var sha256 = (text) => {
-  const uint8Array = toUTF8Array(text);
-  const hashBytes = (0, import_sha256.sha256)(uint8Array);
+  const uint8Array = typeof text === "string" ? toUTF8Array(text) : new Uint8Array(text);
+  const hashBytes = (0, import_sha2.sha256)(uint8Array);
   return hashBytes;
 };
-var hasher = (data, algorithm) => {
-  if (toCryptoAlg(algorithm) !== "sha256") {
-    throw new import_utils.SDJWTException("Not implemented");
+var sha384 = (text) => {
+  const uint8Array = typeof text === "string" ? toUTF8Array(text) : new Uint8Array(text);
+  const hashBytes = (0, import_sha2.sha384)(uint8Array);
+  return hashBytes;
+};
+var sha512 = (text) => {
+  const uint8Array = typeof text === "string" ? toUTF8Array(text) : new Uint8Array(text);
+  const hashBytes = (0, import_sha2.sha512)(uint8Array);
+  return hashBytes;
+};
+var hasher = (data, algorithm = "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 import_utils.SDJWTException(`Unsupported algorithm: ${algorithm}`);
   }
-  return sha256(data);
 };
 var toCryptoAlg = (hashAlg) => (
   // To cover sha-256, sha256, SHA-256, SHA256
@@ -72,5 +92,7 @@ function toUTF8Array(str) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   hasher,
-  sha256
+  sha256,
+  sha384,
+  sha512
 });

package/dist/index.mjs

@@ -1,16 +1,38 @@
-// src/sha256.ts
-import { sha256 as nobleSha256 } from "@noble/hashes/sha256";
+// src/sha.ts
+import {
+  sha256 as nobleSha256,
+  sha384 as nobleSha384,
+  sha512 as nobleSha512
+} from "@noble/hashes/sha2.js";
 import { SDJWTException } from "@sd-jwt/utils";
 var sha256 = (text) => {
-  const uint8Array = toUTF8Array(text);
+  const uint8Array = typeof text === "string" ? toUTF8Array(text) : new Uint8Array(text);
   const hashBytes = nobleSha256(uint8Array);
   return hashBytes;
 };
-var hasher = (data, algorithm) => {
-  if (toCryptoAlg(algorithm) !== "sha256") {
-    throw new SDJWTException("Not implemented");
+var sha384 = (text) => {
+  const uint8Array = typeof text === "string" ? toUTF8Array(text) : new Uint8Array(text);
+  const hashBytes = nobleSha384(uint8Array);
+  return hashBytes;
+};
+var sha512 = (text) => {
+  const uint8Array = typeof text === "string" ? toUTF8Array(text) : new Uint8Array(text);
+  const hashBytes = nobleSha512(uint8Array);
+  return hashBytes;
+};
+var hasher = (data, algorithm = "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}`);
   }
-  return sha256(data);
 };
 var toCryptoAlg = (hashAlg) => (
   // To cover sha-256, sha256, SHA-256, SHA256
@@ -44,5 +66,7 @@ function toUTF8Array(str) {
 }
 export {
   hasher,
-  sha256
+  sha256,
+  sha384,
+  sha512
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sd-jwt/hash",
-  "version": "0.12.1-next.0+36e0b22",
+  "version": "0.12.1-next.1+0a2f20b",
   "description": "sd-jwt draft 7 implementation in typescript",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -38,11 +38,11 @@
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "@sd-jwt/crypto-nodejs": "0.12.1-next.0+36e0b22"
+    "@sd-jwt/crypto-nodejs": "0.12.1-next.1+0a2f20b"
   },
   "dependencies": {
-    "@noble/hashes": "1.0.0",
-    "@sd-jwt/utils": "0.12.1-next.0+36e0b22"
+    "@noble/hashes": "^1.8.0",
+    "@sd-jwt/utils": "0.12.1-next.1+0a2f20b"
   },
   "publishConfig": {
     "access": "public"
@@ -60,5 +60,5 @@
       "esm"
     ]
   },
-  "gitHead": "36e0b22eb619f3ca9ae8522a26617e50c3680526"
+  "gitHead": "0a2f20b6383d2356540e7a9cc37748c7b9caced2"
 }

package/src/index.ts

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

package/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);
+}

package/src/test/{sha256.spec.ts → sha.spec.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));
+      },
+    );
+  });
 });

package/src/sha256.ts

@@ -1,54 +0,0 @@
-import { sha256 as nobleSha256 } from '@noble/hashes/sha256';
-import { SDJWTException } from '@sd-jwt/utils';
-
-export const sha256 = (text: string): Uint8Array => {
-  const uint8Array = toUTF8Array(text);
-  const hashBytes = nobleSha256(uint8Array);
-  return hashBytes;
-};
-
-export const hasher = (data: string, algorithm: string) => {
-  if (toCryptoAlg(algorithm) !== 'sha256') {
-    throw new SDJWTException('Not implemented');
-  }
-  return sha256(data);
-};
-
-const toCryptoAlg = (hashAlg: string): 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);
-}