@ideem/zsm-client-sdk 2.2.3 → 2.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name"          : "@ideem/zsm-client-sdk",
-    "version"       : "2.2.3",
+    "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" ],

package/zsm-client-sdk.js

@@ -1536,10 +1536,15 @@ 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 => response.ok
-                                    ? response.json()
-                                    : response.json().then(errData => { throw new Error(`Request failed: ${response.statusText}, ${JSON.stringify(errData)}`) })
+            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)
             );
         }
 
@@ -1629,7 +1634,7 @@ function base64ToArrayBuffer(base64) {
             "api_path"                 : "INLINE_WASM",
             "installation_description" : (typeof window !== 'undefined' ? window?.navigator?.userAgent : ''),
             "log_level"                : 'Debug',
-            "request_timeout_ms"       : 1000,
+            "request_timeout_ms"       : 100000,
             "retry_count"              : 0,
             "consumer_id"              : "",
         };
@@ -1688,22 +1693,21 @@ function base64ToArrayBuffer(base64) {
         * @param {string} username - The username.
         * @returns {Promise<string>} Resolves with the identity_id if it exists.
         */
-        webauthnRetrieve = (userIdentifier, silent=false) => {
+        webauthnRetrieve = async (userIdentifier, silent=false) => {
             this.credentialID = null;
             if(!silent) this.status='CREDENTIAL_RETRIEVING';
-            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);
-            });
+            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;
         }
         
         /**
@@ -1712,17 +1716,19 @@ 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 = (userIdentifier, createNewIdentity=false) => {
-            this.status='CHECKING_IDENTITY_STARTING';
-            
-            return this.initializeZsm(userIdentifier)
-            .then(() => this.#relyingParty.checkServerSideIdentity(createNewIdentity))
-            .then(result => (result.identity_id) )
-            .catch(error => {
+        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) {
                 this.status='CHECKING_IDENTITY_FAILED';
-                this.#relyingParty.clearLoginCredentials();
-                return Promise.reject(error);
-            })
+                return Promise.reject(err);
+            }
         }
         
         /**
@@ -1730,24 +1736,28 @@ function base64ToArrayBuffer(base64) {
         * @param {string} userIdentifier - The userIdentifier.
         * @returns {Promise<Object>} Resolves with the created credential.
         */
-        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);
-                });
+        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);
+            }
         }
     
         /**
@@ -1755,32 +1765,40 @@ function base64ToArrayBuffer(base64) {
         * @param {string} userIdentifier - The userIdentifier.
         * @returns {Promise<Object>} Resolves with the signed challenge and authentication details.
         */
-        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 => {
+        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) {
                 this.status='AUTHENTICATION_FAILED';
-                this.#relyingParty.clearLoginCredentials();
-                return Promise.reject(error);
-            })
+                return Promise.reject(err);
+            }
         }
 
         /**
@@ -1840,16 +1858,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(); }