@dfns/sdk-keysigner 0.3.2 → 0.3.4

package/index.d.ts

@@ -1,4 +1,4 @@
-import { CredentialSigner, KeyAssertion } from '@dfns/sdk';
+import { CredentialSigner, KeyAssertion, UserRegistrationChallenge, KeyAttestation } from '@dfns/sdk';
 export declare class AsymmetricKeySigner implements CredentialSigner<KeyAssertion> {
     private options;
     constructor(options: {
@@ -13,12 +13,11 @@ export declare class AsymmetricKeySigner implements CredentialSigner<KeyAssertio
 export declare class BrowserKeySigner implements CredentialSigner<KeyAssertion> {
     private options;
     constructor(options: {
-        privateKey: CryptoKey;
-        credId: string;
+        keyPair: CryptoKeyPair;
+        credId?: string;
         appOrigin: string;
         crossOrigin?: boolean;
     });
-    minimizeBigInt: (value: Uint8Array) => Uint8Array;
-    rawSignatureToAns1: (rawSignature: Uint8Array) => Uint8Array;
+    create(challenge: UserRegistrationChallenge): Promise<KeyAttestation>;
     sign(challenge: string): Promise<KeyAssertion>;
 }

package/index.js

@@ -51,37 +51,53 @@ exports.AsymmetricKeySigner = AsymmetricKeySigner;
 class BrowserKeySigner {
     constructor(options) {
         this.options = options;
-        this.minimizeBigInt = (value) => {
-            const minValue = [0, ...value];
-            for (let i = 0; i < minValue.length; ++i) {
-                if (minValue[i] === 0) {
-                    continue;
-                }
-                if (minValue[i] > 0x7f) {
-                    return new Uint8Array(minValue.slice(i - 1));
-                }
-                return new Uint8Array(minValue.slice(i));
-            }
-            return new Uint8Array([0]);
-        };
-        this.rawSignatureToAns1 = (rawSignature) => {
-            const r = rawSignature.slice(0, 32);
-            const s = rawSignature.slice(32);
-            const minR = this.minimizeBigInt(r);
-            const minS = this.minimizeBigInt(s);
-            return new Uint8Array([
-                0x30,
-                minR.length + minS.length + 4,
-                0x02,
-                minR.length,
-                ...minR,
-                0x02,
-                minS.length,
-                ...minS
-            ]);
+    }
+    async create(challenge) {
+        let credId = this.options.credId;
+        if (credId === undefined || credId === '') {
+            credId = (0, utils_1.toBase64Url)(Buffer.from((0, utils_1.generateRandom)(32)));
+            this.options.credId = credId;
+        }
+        const publicKeyPem = await (0, utils_1.exportPublicKeyInPemFormatBrowser)(this.options.keyPair);
+        const clientData = JSON.stringify({
+            type: 'key.create',
+            challenge: challenge.challenge,
+            origin: this.options.appOrigin,
+            crossOrigin: this.options.crossOrigin ?? false,
+        });
+        const clientDataHash = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(clientData));
+        const clientDataHashHex = (0, utils_1.toHex)(clientDataHash);
+        const credInfoFingerprint = JSON.stringify({
+            clientDataHash: clientDataHashHex,
+            publicKey: publicKeyPem,
+        });
+        let rawSignature;
+        const algorithm = this.options.keyPair.privateKey.algorithm.name;
+        if (algorithm == 'ECDSA') {
+            rawSignature = await crypto.subtle.sign({ name: 'ECDSA', hash: { name: 'SHA-256' } }, this.options.keyPair.privateKey, new TextEncoder().encode(credInfoFingerprint));
+        }
+        else {
+            throw new Error(`${algorithm} is not supported`);
+        }
+        const signature = (0, utils_1.rawSignatureToAns1)(new Uint8Array(rawSignature));
+        const attestationData = JSON.stringify({
+            publicKey: publicKeyPem,
+            signature: (0, utils_1.toHex)(signature)
+        });
+        return {
+            credentialKind: 'Key',
+            credentialInfo: {
+                credId: credId,
+                clientData: (0, utils_1.toBase64Url)(clientData),
+                attestationData: (0, utils_1.toBase64Url)(attestationData),
+            },
         };
     }
     async sign(challenge) {
+        const credId = this.options.credId;
+        if (credId === undefined || credId === '') {
+            throw new Error('credId is needed to sign');
+        }
         const clientData = JSON.stringify({
             type: 'key.get',
             challenge,
@@ -89,18 +105,18 @@ class BrowserKeySigner {
             crossOrigin: this.options.crossOrigin ?? false,
         });
         let rawSignature;
-        const algorithm = this.options.privateKey.algorithm.name;
+        const algorithm = this.options.keyPair.privateKey.algorithm.name;
         if (algorithm == 'ECDSA') {
-            rawSignature = await crypto.subtle.sign({ name: 'ECDSA', hash: { name: 'SHA-256' } }, this.options.privateKey, new TextEncoder().encode(clientData));
+            rawSignature = await crypto.subtle.sign({ name: 'ECDSA', hash: { name: 'SHA-256' } }, this.options.keyPair.privateKey, new TextEncoder().encode(clientData));
         }
         else {
             throw new Error(`${algorithm} is not supported`);
         }
-        const signature = this.rawSignatureToAns1(new Uint8Array(rawSignature));
+        const signature = (0, utils_1.rawSignatureToAns1)(new Uint8Array(rawSignature));
         return {
             kind: 'Key',
             credentialAssertion: {
-                credId: this.options.credId,
+                credId: this.options.credId ?? '',
                 clientData: (0, utils_1.toBase64Url)(clientData),
                 signature: (0, utils_1.toBase64Url)(Buffer.from(signature)),
             },

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@dfns/sdk-keysigner",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "dependencies": {
     "buffer": "6.0.3",
     "cross-fetch": "3.1.6",
     "uuid": "9.0.0"
   },
   "peerDependencies": {
-    "@dfns/sdk": "0.3.2"
+    "@dfns/sdk": "0.3.4"
   },
   "main": "./index.js",
   "type": "commonjs"