@sd-jwt/crypto-browser 0.3.2-next.71 → 0.3.2-next.73

package/dist/index.d.mts

@@ -1,5 +1,14 @@
 declare const generateSalt: (length: number) => string;
 declare function digest(data: string, algorithm?: string): Promise<Uint8Array>;
 declare const getHasher: (algorithm?: string) => (data: string) => Promise<Uint8Array>;
+declare const ES256: {
+    alg: string;
+    generateKeyPair(): Promise<{
+        publicKey: JsonWebKey;
+        privateKey: JsonWebKey;
+    }>;
+    getSigner(privateKeyJWK: object): Promise<(data: string) => Promise<string>>;
+    getVerifier(publicKeyJWK: object): Promise<(data: string, signatureBase64url: string) => Promise<boolean>>;
+};
 
-export { digest, generateSalt, getHasher };
+export { ES256, digest, generateSalt, getHasher };

package/dist/index.d.ts

@@ -1,5 +1,14 @@
 declare const generateSalt: (length: number) => string;
 declare function digest(data: string, algorithm?: string): Promise<Uint8Array>;
 declare const getHasher: (algorithm?: string) => (data: string) => Promise<Uint8Array>;
+declare const ES256: {
+    alg: string;
+    generateKeyPair(): Promise<{
+        publicKey: JsonWebKey;
+        privateKey: JsonWebKey;
+    }>;
+    getSigner(privateKeyJWK: object): Promise<(data: string) => Promise<string>>;
+    getVerifier(publicKeyJWK: object): Promise<(data: string, signatureBase64url: string) => Promise<boolean>>;
+};
 
-export { digest, generateSalt, getHasher };
+export { ES256, digest, generateSalt, getHasher };

package/dist/index.js

@@ -40,6 +40,7 @@ var __async = (__this, __arguments, generator) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  ES256: () => ES256,
   digest: () => digest,
   generateSalt: () => generateSalt,
   getHasher: () => getHasher
@@ -69,8 +70,99 @@ function digest(data, algorithm = "SHA-256") {
 var getHasher = (algorithm = "SHA-256") => {
   return (data) => digest(data, algorithm);
 };
+var ES256 = {
+  alg: "ES256",
+  generateKeyPair() {
+    return __async(this, null, function* () {
+      const keyPair = yield window.crypto.subtle.generateKey(
+        {
+          name: "ECDSA",
+          namedCurve: "P-256"
+          // ES256
+        },
+        true,
+        // whether the key is extractable (i.e., can be used in exportKey)
+        ["sign", "verify"]
+        // can be used to sign and verify signatures
+      );
+      const publicKeyJWK = yield window.crypto.subtle.exportKey(
+        "jwk",
+        keyPair.publicKey
+      );
+      const privateKeyJWK = yield window.crypto.subtle.exportKey(
+        "jwk",
+        keyPair.privateKey
+      );
+      return { publicKey: publicKeyJWK, privateKey: privateKeyJWK };
+    });
+  },
+  getSigner(privateKeyJWK) {
+    return __async(this, null, function* () {
+      const privateKey = yield window.crypto.subtle.importKey(
+        "jwk",
+        privateKeyJWK,
+        {
+          name: "ECDSA",
+          namedCurve: "P-256"
+          // Must match the curve used to generate the key
+        },
+        true,
+        // whether the key is extractable (i.e., can be used in exportKey)
+        ["sign"]
+      );
+      return (data) => __async(this, null, function* () {
+        const encoder = new TextEncoder();
+        const signature = yield window.crypto.subtle.sign(
+          {
+            name: "ECDSA",
+            hash: { name: "SHA-256" }
+            // Required for ES256
+          },
+          privateKey,
+          encoder.encode(data)
+        );
+        return window.btoa(String.fromCharCode(...new Uint8Array(signature))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+      });
+    });
+  },
+  getVerifier(publicKeyJWK) {
+    return __async(this, null, function* () {
+      const publicKey = yield window.crypto.subtle.importKey(
+        "jwk",
+        publicKeyJWK,
+        {
+          name: "ECDSA",
+          namedCurve: "P-256"
+          // Must match the curve used to generate the key
+        },
+        true,
+        // whether the key is extractable (i.e., can be used in exportKey)
+        ["verify"]
+      );
+      return (data, signatureBase64url) => __async(this, null, function* () {
+        const encoder = new TextEncoder();
+        const signature = Uint8Array.from(
+          atob(signatureBase64url.replace(/-/g, "+").replace(/_/g, "/")),
+          (c) => c.charCodeAt(0)
+        );
+        const isValid = yield window.crypto.subtle.verify(
+          {
+            name: "ECDSA",
+            hash: { name: "SHA-256" }
+            // Required for ES256
+          },
+          publicKey,
+          signature,
+          encoder.encode(data)
+        );
+        return isValid;
+      });
+    });
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ES256,
   digest,
   generateSalt,
   getHasher

package/dist/index.mjs

@@ -42,7 +42,98 @@ function digest(data, algorithm = "SHA-256") {
 var getHasher = (algorithm = "SHA-256") => {
   return (data) => digest(data, algorithm);
 };
+var ES256 = {
+  alg: "ES256",
+  generateKeyPair() {
+    return __async(this, null, function* () {
+      const keyPair = yield window.crypto.subtle.generateKey(
+        {
+          name: "ECDSA",
+          namedCurve: "P-256"
+          // ES256
+        },
+        true,
+        // whether the key is extractable (i.e., can be used in exportKey)
+        ["sign", "verify"]
+        // can be used to sign and verify signatures
+      );
+      const publicKeyJWK = yield window.crypto.subtle.exportKey(
+        "jwk",
+        keyPair.publicKey
+      );
+      const privateKeyJWK = yield window.crypto.subtle.exportKey(
+        "jwk",
+        keyPair.privateKey
+      );
+      return { publicKey: publicKeyJWK, privateKey: privateKeyJWK };
+    });
+  },
+  getSigner(privateKeyJWK) {
+    return __async(this, null, function* () {
+      const privateKey = yield window.crypto.subtle.importKey(
+        "jwk",
+        privateKeyJWK,
+        {
+          name: "ECDSA",
+          namedCurve: "P-256"
+          // Must match the curve used to generate the key
+        },
+        true,
+        // whether the key is extractable (i.e., can be used in exportKey)
+        ["sign"]
+      );
+      return (data) => __async(this, null, function* () {
+        const encoder = new TextEncoder();
+        const signature = yield window.crypto.subtle.sign(
+          {
+            name: "ECDSA",
+            hash: { name: "SHA-256" }
+            // Required for ES256
+          },
+          privateKey,
+          encoder.encode(data)
+        );
+        return window.btoa(String.fromCharCode(...new Uint8Array(signature))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+      });
+    });
+  },
+  getVerifier(publicKeyJWK) {
+    return __async(this, null, function* () {
+      const publicKey = yield window.crypto.subtle.importKey(
+        "jwk",
+        publicKeyJWK,
+        {
+          name: "ECDSA",
+          namedCurve: "P-256"
+          // Must match the curve used to generate the key
+        },
+        true,
+        // whether the key is extractable (i.e., can be used in exportKey)
+        ["verify"]
+      );
+      return (data, signatureBase64url) => __async(this, null, function* () {
+        const encoder = new TextEncoder();
+        const signature = Uint8Array.from(
+          atob(signatureBase64url.replace(/-/g, "+").replace(/_/g, "/")),
+          (c) => c.charCodeAt(0)
+        );
+        const isValid = yield window.crypto.subtle.verify(
+          {
+            name: "ECDSA",
+            hash: { name: "SHA-256" }
+            // Required for ES256
+          },
+          publicKey,
+          signature,
+          encoder.encode(data)
+        );
+        return isValid;
+      });
+    });
+  }
+};
 export {
+  ES256,
   digest,
   generateSalt,
   getHasher

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sd-jwt/crypto-browser",
-  "version": "0.3.2-next.71+0dbc55c",
+  "version": "0.3.2-next.73+2d8206e",
   "description": "sd-jwt draft 7 implementation in typescript",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -49,5 +49,5 @@
       "esm"
     ]
   },
-  "gitHead": "0dbc55ce2cd8fafe107422a28edafb61501416fd"
+  "gitHead": "2d8206e45a61630743be32fe8d490bf001d82a5e"
 }

package/src/crypto.ts

@@ -25,3 +25,93 @@ export async function digest(
 export const getHasher = (algorithm = 'SHA-256') => {
   return (data: string) => digest(data, algorithm);
 };
+
+export const ES256 = {
+  alg: 'ES256',
+
+  async generateKeyPair() {
+    const keyPair = await window.crypto.subtle.generateKey(
+      {
+        name: 'ECDSA',
+        namedCurve: 'P-256', // ES256
+      },
+      true, // whether the key is extractable (i.e., can be used in exportKey)
+      ['sign', 'verify'], // can be used to sign and verify signatures
+    );
+
+    // Export the public and private keys in JWK format
+    const publicKeyJWK = await window.crypto.subtle.exportKey(
+      'jwk',
+      keyPair.publicKey,
+    );
+    const privateKeyJWK = await window.crypto.subtle.exportKey(
+      'jwk',
+      keyPair.privateKey,
+    );
+
+    return { publicKey: publicKeyJWK, privateKey: privateKeyJWK };
+  },
+
+  async getSigner(privateKeyJWK: object) {
+    const privateKey = await window.crypto.subtle.importKey(
+      'jwk',
+      privateKeyJWK,
+      {
+        name: 'ECDSA',
+        namedCurve: 'P-256', // Must match the curve used to generate the key
+      },
+      true, // whether the key is extractable (i.e., can be used in exportKey)
+      ['sign'],
+    );
+
+    return async (data: string) => {
+      const encoder = new TextEncoder();
+      const signature = await window.crypto.subtle.sign(
+        {
+          name: 'ECDSA',
+          hash: { name: 'SHA-256' }, // Required for ES256
+        },
+        privateKey,
+        encoder.encode(data),
+      );
+
+      return window
+        .btoa(String.fromCharCode(...new Uint8Array(signature)))
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/, ''); // Convert to base64url format
+    };
+  },
+
+  async getVerifier(publicKeyJWK: object) {
+    const publicKey = await window.crypto.subtle.importKey(
+      'jwk',
+      publicKeyJWK,
+      {
+        name: 'ECDSA',
+        namedCurve: 'P-256', // Must match the curve used to generate the key
+      },
+      true, // whether the key is extractable (i.e., can be used in exportKey)
+      ['verify'],
+    );
+
+    return async (data: string, signatureBase64url: string) => {
+      const encoder = new TextEncoder();
+      const signature = Uint8Array.from(
+        atob(signatureBase64url.replace(/-/g, '+').replace(/_/g, '/')),
+        (c) => c.charCodeAt(0),
+      );
+      const isValid = await window.crypto.subtle.verify(
+        {
+          name: 'ECDSA',
+          hash: { name: 'SHA-256' }, // Required for ES256
+        },
+        publicKey,
+        signature,
+        encoder.encode(data),
+      );
+
+      return isValid;
+    };
+  },
+};

package/src/test/crypto.spec.ts

@@ -1,5 +1,5 @@
-import { describe, expect, test, it } from 'vitest';
-import { generateSalt, digest, getHasher } from '../index';
+import { describe, expect, test } from 'vitest';
+import { generateSalt, digest, getHasher, ES256 } from '../index';
 
 // Extract the major version as a number
 const nodeVersionMajor = parseInt(
@@ -41,4 +41,25 @@ describe('This file is for utility functions', () => {
     const hash = await getHasher('SHA-512')('test1');
     expect(hash).toBeDefined();
   });
+
+  (nodeVersionMajor < 20 ? test.skip : test)('ES256 alg', () => {
+    expect(ES256.alg).toBe('ES256');
+  });
+
+  (nodeVersionMajor < 20 ? test.skip : test)('ES256', async () => {
+    const { privateKey, publicKey } = await ES256.generateKeyPair();
+    expect(privateKey).toBeDefined();
+    expect(publicKey).toBeDefined();
+    expect(typeof privateKey).toBe('object');
+    expect(typeof publicKey).toBe('object');
+
+    const data =
+      'In cryptography, a salt is random data that is used as an additional input to a one-way function that hashes data, a password or passphrase.';
+    const signature = await (await ES256.getSigner(privateKey))(data);
+    expect(signature).toBeDefined();
+    expect(typeof signature).toBe('string');
+
+    const result = await (await ES256.getVerifier(publicKey))(data, signature);
+    expect(result).toBe(true);
+  });
 });