@ideem/zsm-client-sdk 2.2.4 → 2.2.5

package/package.json

@@ -1,29 +1,49 @@
 {
-    "name"          : "@ideem/zsm-client-sdk",
-    "version"       : "2.2.4",
-    "description"   : "A monolithic library exporting UMFAClient and FIDO2Client.",
-    "author"        : "@JJ (Jason Jurusz) <jj@useideem.com>/<nerdy.deeds@done.cheap>",
-    "keywords"      : [ "ideem", "zsm", "zsm-client-sdk", "UMFAClient", "FIDO2Client", "library", "UMFA", "FIDO2", "client", "authentication", "javascript", "multi-factor", "webauthn", "authentication", "security" ],
-    "scripts"       : { 
-        "start"     : "echo 'This is a library, not an application. No start script defined. To use, import the library.'",
-        "postpack"  : "rm -rf ./*.tgz 2>/dev/null && fn=\"$(ls -1 ../ | grep -e ^ideem-zsm)\" && mv \"../$fn\" \"../$(sed -e \"s/^ideem-//\" <<< \"$fn\")\""
+    "name": "@ideem/zsm-client-sdk",
+    "version": "2.2.5",
+    "description": "A monolithic library exporting UMFAClient and FIDO2Client.",
+    "author": "@JJ (Jason Jurusz) <jj@useideem.com>/<nerdy.deeds@done.cheap>",
+    "keywords": [
+        "ideem",
+        "zsm",
+        "zsm-client-sdk",
+        "UMFAClient",
+        "FIDO2Client",
+        "library",
+        "UMFA",
+        "FIDO2",
+        "client",
+        "authentication",
+        "javascript",
+        "multi-factor",
+        "webauthn",
+        "authentication",
+        "security"
+    ],
+    "scripts": {
+        "start": "echo 'This is a library, not an application. No start script defined. To use, import the library.'",
+        "inc": "npm version patch && cd ..; sleep 1; npm pack ./npm-package"
     },
-    "collaborators" : [
-                        "Joel Teply <joel@useideem.com>",
-                        "Todd Decker <todd@useideem.com>",
-                        "Brian Koziel <brian@useideem.com>",
-                        "@JJ <jj@useideem.com>"
+    "collaborators": [
+        "Joel Teply <joel@useideem.com>",
+        "Todd Decker <todd@useideem.com>",
+        "Brian Koziel <brian@useideem.com>",
+        "@JJ <jj@useideem.com>"
     ],
-    "main"          : "zsm-client-sdk.js",
-    "module"        : "zsm-client-sdk.js",
-    "browser"       : "zsm-client-sdk.js",
-    "license"       : "SEE LICENSE IN LICENSE",
-    "repository"    : {
-        "type"      : "git",
-        "url"       : "https://github.com/useideem/vHSM.git"
+    "main": "zsm-client-sdk.js",
+    "module": "zsm-client-sdk.js",
+    "browser": "zsm-client-sdk.js",
+    "license": "SEE LICENSE IN LICENSE",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/useideem/vHSM.git"
     },
-    "bugs"          : "https://github.com/useideem/vHSM/issues",
-    "homepage"      : "http://useideem.com",
-    "files"         : ["zsm-client-sdk.js"],
-    "engines"       : { "node"  : ">=20.0.0"}
+    "bugs": "https://github.com/useideem/vHSM/issues",
+    "homepage": "http://useideem.com",
+    "files": [
+        "zsm-client-sdk.js"
+    ],
+    "engines": {
+        "node": ">=20.0.0"
+    }
 }

package/zsm-client-sdk.js

@@ -1421,7 +1421,7 @@ let wasm_bindgen;
             if (Object.getPrototypeOf(module) === Object.prototype) {
                 ({module} = module)
             } else {
-                console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+                // console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
             }
         }
 
@@ -1527,8 +1527,6 @@ function base64ToArrayBuffer(base64) {
 
         #makePostRequest = (url, body={}, headers={}, method='POST') => {
             url = `${this.host.endsWith('/') ? this.host.slice(0,-1) : this.host}/${url.startsWith('/') ? url.slice(1) : url}`;
-            console.log('url :', url);
-
             body = ((typeof body === 'object') ? body : {});
             body = Object.assign({customer_defined_identifier: this.customerDefinedIdentifier, application_id: this.applicationId}, body);
             let fetchObj = {
@@ -1536,15 +1534,10 @@ function base64ToArrayBuffer(base64) {
                 headers : Object.assign(this.xhrHeaders, ((!headers?.Authorization) ? {'Authorization': `Bearer ${this.#apiKey}`} : {}), headers),
                 body    : JSON.stringify(body)
             };
-            return  fetch(url, fetchObj)
-                    .then(response => console.log('response, response.ok :', response, response.ok) || response)
-                    .then(response => {
-                        if(!response.ok) throw new Error(`Request failed: ${response.statusText}`);
-                        let responseJSON = response.json();
-                        console.log('responseJSON :', responseJSON);
-                        return responseJSON;
-                    })
-                    .catch(response => console.error('makePostRequest ERROR :: ', response)
+            return fetch(url, fetchObj)
+                    .then(response => response.ok
+                                    ? response.json()
+                                    : response.json().then(errData => { throw new Error(`Request failed: ${response.statusText}, ${JSON.stringify(errData)}`) })
             );
         }
 
@@ -1634,7 +1627,7 @@ function base64ToArrayBuffer(base64) {
             "api_path"                 : "INLINE_WASM",
             "installation_description" : (typeof window !== 'undefined' ? window?.navigator?.userAgent : ''),
             "log_level"                : 'Debug',
-            "request_timeout_ms"       : 100000,
+            "request_timeout_ms"       : 30000,
             "retry_count"              : 0,
             "consumer_id"              : "",
         };
@@ -1693,21 +1686,22 @@ function base64ToArrayBuffer(base64) {
         * @param {string} username - The username.
         * @returns {Promise<string>} Resolves with the identity_id if it exists.
         */
-        webauthnRetrieve = async (userIdentifier, silent=false) => {
+        webauthnRetrieve = (userIdentifier, silent=false) => {
             this.credentialID = null;
             if(!silent) this.status='CREDENTIAL_RETRIEVING';
-            await this.initializeZsm(userIdentifier)
-            const retrievedUser = await this.#zsmApi.webauthn_retrieve(userIdentifier);
-            if(retrievedUser.error) return false;
-
-            const userData     = retrievedUser.result;
-
-            const userDataRes  = (!Object.entries(userData).length) ? Object.fromEntries(userData.entries()) : userData;
-            const userRawId    = userDataRes.rawId || undefined;
-
-            if(!userRawId) return false;
-            this.credentialID = userRawId;
-            return userRawId;
+            return this.initializeZsm(userIdentifier)
+            .then(() => this.#zsmApi.webauthn_retrieve(userIdentifier))
+            .then(response => {
+                if(response.error) return false;
+                let rawId = response.result?.get("rawId") || undefined;
+                this.credentialID = rawId;
+                if(!silent) this.status='CREDENTIAL_RETRIEVED'; 
+                return rawId;
+            })
+            .catch(error => {
+                this.status='CREDENTIAL_RETRIEVAL_FAILED';
+                return Promise.reject(error);
+            });
         }
         
         /**
@@ -1716,19 +1710,17 @@ function base64ToArrayBuffer(base64) {
         * @param {boolean} createNewIdentity Create a new identity if one does not already exist
         * @returns {Promise<Object>} Resolves with the retrieved identity if it exists.
         */
-        checkIdentity = async (userIdentifier, createNewIdentity=false) => {
-            try { 
-                this.status='CHECKING_IDENTITY_STARTING';
-                await this.initializeZsm(userIdentifier);
-                const resultOfCheck = await this.#relyingParty.checkServerSideIdentity(createNewIdentity);
-                if(!resultOfCheck) throw new Error('Unable to communicate with identity server!');
-                const identityID    = resultOfCheck.identity_id;
-                if(!identityID) throw new Error('Unable to acquire identity_id!');
-                return identityID;
-            } catch(err) {
+        checkIdentity = (userIdentifier, createNewIdentity=false) => {
+            this.status='CHECKING_IDENTITY_STARTING';
+            
+            return this.initializeZsm(userIdentifier)
+            .then(() => this.#relyingParty.checkServerSideIdentity(createNewIdentity))
+            .then(result => (result.identity_id) )
+            .catch(error => {
                 this.status='CHECKING_IDENTITY_FAILED';
-                return Promise.reject(err);
-            }
+                this.#relyingParty.clearLoginCredentials();
+                return Promise.reject(error);
+            })
         }
         
         /**
@@ -1736,28 +1728,24 @@ function base64ToArrayBuffer(base64) {
         * @param {string} userIdentifier - The userIdentifier.
         * @returns {Promise<Object>} Resolves with the created credential.
         */
-        webauthnCreate = async (userIdentifier) => {
-            try {
-                this.status='ENROLLMENT_STARTING';
-                await this.initializeZsm(userIdentifier);
-                const publicKey   = await this.#relyingParty.registrationStart();
-                const webAuthnRes = await this.#zsmApi.webauthn_create(publicKey);
-                
-                if(!webAuthnRes?.result) throw new Error('[mpc_round] webauthnCreate failed');
-
-                const credObjRAW  = webAuthnRes.result;
-                const credential  = (!Object.entries(credObjRAW).length) ? Object.fromEntries(credObjRAW.entries()) : credObjRAW;
-
-                if(!credential.response) throw new Error('Unable to acquire attestation object!');
-                credential.response = (!Object.entries(credential.response).length) ? Object.fromEntries(credential.response.entries()) : credential.response;
-
-                const regObject   = await this.#relyingParty.registrationFinish(credential);
-                return regObject;
-            } catch(err) {
-                this.status='ENROLLMENT_FAILED';
-                this.#relyingParty.clearEnrollmentCredentials();
-                return Promise.reject(err);
-            }
+        webauthnCreate = userIdentifier => {
+            this.status='ENROLLMENT_STARTING';
+            return this.initializeZsm(userIdentifier)
+                .then(() => this.#relyingParty.registrationStart())
+                .then(publicKey => this.#zsmApi.webauthn_create(publicKey))
+                .then(response => {
+                    let result = response.result;
+                    const credential = Object.fromEntries(
+                        [...result.entries()].map(([k, v]) => [k, k === 'response' ? Object.fromEntries(v.entries()) : v])
+                    );
+                    this.status='ENROLLMENT_FINISHED'
+                    return this.#relyingParty.registrationFinish(credential);
+                })
+                .catch(error => {
+                    this.status='ENROLLMENT_FAILED';
+                    this.#relyingParty.clearLoginCredentials();
+                    return Promise.reject(error);
+                });
         }
     
         /**
@@ -1765,40 +1753,32 @@ function base64ToArrayBuffer(base64) {
         * @param {string} userIdentifier - The userIdentifier.
         * @returns {Promise<Object>} Resolves with the signed challenge and authentication details.
         */
-        webauthnGet = async (userIdentifier) => {
-            try {
-                this.status='AUTHENTICATION_STARTING';
-                await this.initializeZsm(userIdentifier)
-                if(!this.isEnrolled) throw new Error(`Credential is missing for ${userIdentifier}`);
-
-                const authData  = await this.#relyingParty.authenticationStart(this.credentialID);
-                if(!authData?.rcr?.publicKey) throw new Error(`Unable to acquire public key!`);
-                
-                const publicKey = authData.rcr.publicKey;
-                const challenge = publicKey.challenge;
-
-                const webAuthnRes = await this.#zsmApi.webauthn_get(publicKey);
-                const credObjRAW  = webAuthnRes.result;
-                const credential  = (!Object.entries(credObjRAW).length) ? Object.fromEntries(credObjRAW.entries()) : credObjRAW;
-                credential.challenge = challenge;
-
-                if(!credential.response) throw new Error('Unable to acquire credential challenge response!');
-                credential.response = (!Object.entries(credential.response).length) ? Object.fromEntries(credential.response.entries()) : credential.response;
-
-                const authObject = await this.#relyingParty.authenticationFinish(credential);
-                const authOutput = {
-                    signature       : credential.response.signature,
-                    signedChallenge : credential.response.clientDataJSON,
-                    user_id         : authObject.user_id,
-                    token           : authObject.token,
-                    challenge,
-                    credential
-                }
-                return authOutput;
-            } catch(err) {
+        webauthnGet = userIdentifier => {
+            this.status='AUTHENTICATION_STARTING';
+            return this.initializeZsm(userIdentifier)
+            .then(() => this.isEnrolled
+                    ? this.#relyingParty.authenticationStart(this.credentialID)
+                    : Promise.reject(new Error(`Credential is missing for ${userIdentifier}`))
+            )
+            .then(data => this.#zsmApi.webauthn_get(data.rcr.publicKey)
+                                .then(response => ({ response, challenge: data.rcr.publicKey.challenge }))
+            )
+            .then(({ response, challenge }) => {
+                const credential = Object.fromEntries([...response.result.entries()].map(([k, v]) => [k, k === 'response' ? Object.fromEntries(v.entries()) : v]));
+                return this.#relyingParty.authenticationFinish(credential)
+                                        .then((output) => ({
+                                            signature       : credential.response.signature,
+                                            signedChallenge : credential.response.clientDataJSON,
+                                            user_id         : output.user_id,
+                                            token           : output.token,
+                                            challenge,
+                                            credential
+                                        }))
+            }).catch(error => {
                 this.status='AUTHENTICATION_FAILED';
-                return Promise.reject(err);
-            }
+                this.#relyingParty.clearLoginCredentials();
+                return Promise.reject(error);
+            })
         }
 
         /**
@@ -1858,16 +1838,16 @@ function base64ToArrayBuffer(base64) {
         }
         
         authenticate = async (userIdentifier=this.userIdentifier) => { 
-            // try {
+            try {
                 let userIsEnrolled = await this.checkEnrollment(userIdentifier);
                 if(userIsEnrolled === false) throw(`${userIdentifier} is not enrolled.`);
                 let authCredentalIdentity = await this.#zsmAPI.webauthnGet(userIdentifier);
                 return authCredentalIdentity;
-            // } catch(e) {
-            //     e = e.message || e;
-            //     e = 'Unable to authenticate user:' + e;
-            //     return new Error(e);
-            // }
+            } catch(e) {
+                e = e.message || e;
+                e = 'Unable to authenticate user:' + e;
+                return new Error(e);
+            }
         }
 
         resetDevice  = async () => { this.#zsmAPI.webauthnReset(); }