@axa-fr/react-oidc 6.10.15 → 6.10.17

package/src/oidc/vanilla/initWorker.ts

@@ -1,8 +1,78 @@
+import { initSession } from './initSession';
 import { OidcConfiguration } from './oidc';
 import { parseOriginalTokens } from './parseTokens';
 import timer from './timer';
 
-function get_browser() {
+export const getOperatingSystem = () => {
+    const nVer = navigator.appVersion;
+    const nAgt = navigator.userAgent;
+    const unknown = '-';
+    // system
+    let os = unknown;
+    const clientStrings = [
+        { s: 'Windows 10', r: /(Windows 10.0|Windows NT 10.0)/ },
+        { s: 'Windows 8.1', r: /(Windows 8.1|Windows NT 6.3)/ },
+        { s: 'Windows 8', r: /(Windows 8|Windows NT 6.2)/ },
+        { s: 'Windows 7', r: /(Windows 7|Windows NT 6.1)/ },
+        { s: 'Windows Vista', r: /Windows NT 6.0/ },
+        { s: 'Windows Server 2003', r: /Windows NT 5.2/ },
+        { s: 'Windows XP', r: /(Windows NT 5.1|Windows XP)/ },
+        { s: 'Windows 2000', r: /(Windows NT 5.0|Windows 2000)/ },
+        { s: 'Windows ME', r: /(Win 9x 4.90|Windows ME)/ },
+        { s: 'Windows 98', r: /(Windows 98|Win98)/ },
+        { s: 'Windows 95', r: /(Windows 95|Win95|Windows_95)/ },
+        { s: 'Windows NT 4.0', r: /(Windows NT 4.0|WinNT4.0|WinNT|Windows NT)/ },
+        { s: 'Windows CE', r: /Windows CE/ },
+        { s: 'Windows 3.11', r: /Win16/ },
+        { s: 'Android', r: /Android/ },
+        { s: 'Open BSD', r: /OpenBSD/ },
+        { s: 'Sun OS', r: /SunOS/ },
+        { s: 'Chrome OS', r: /CrOS/ },
+        { s: 'Linux', r: /(Linux|X11(?!.*CrOS))/ },
+        { s: 'iOS', r: /(iPhone|iPad|iPod)/ },
+        { s: 'Mac OS X', r: /Mac OS X/ },
+        { s: 'Mac OS', r: /(Mac OS|MacPPC|MacIntel|Mac_PowerPC|Macintosh)/ },
+        { s: 'QNX', r: /QNX/ },
+        { s: 'UNIX', r: /UNIX/ },
+        { s: 'BeOS', r: /BeOS/ },
+        { s: 'OS/2', r: /OS\/2/ },
+        { s: 'Search Bot', r: /(nuhk|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask Jeeves\/Teoma|ia_archiver)/ },
+    ];
+    for (const id in clientStrings) {
+        const cs = clientStrings[id];
+        if (cs.r.test(nAgt)) {
+            os = cs.s;
+            break;
+        }
+    }
+
+    let osVersion = unknown;
+
+    if (/Windows/.test(os)) {
+        osVersion = /Windows (.*)/.exec(os)[1];
+        os = 'Windows';
+    }
+
+    switch (os) {
+        case 'Mac OS':
+        case 'Mac OS X':
+        case 'Android':
+            osVersion = /(?:Android|Mac OS|Mac OS X|MacPPC|MacIntel|Mac_PowerPC|Macintosh) ([._\d]+)/.exec(nAgt)[1];
+            break;
+
+        case 'iOS': {
+            const osVersionArray = /OS (\d+)_(\d+)_?(\d+)?/.exec(nVer);
+            osVersion = osVersionArray[1] + '.' + osVersionArray[2] + '.' + (parseInt(osVersionArray[3]) | 0);
+            break;
+        }
+    }
+    return {
+        os,
+        osVersion,
+    };
+};
+
+function getBrowser() {
     const ua = navigator.userAgent; let tem;
         let M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
     if (/trident/i.test(M[1])) {
@@ -70,11 +140,11 @@ const sendMessageAsync = (registration) => (data) => {
     });
 };
 
-export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName) => {
+export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName, redirectUri) => {
     if (typeof window === 'undefined' || typeof navigator === 'undefined' || !navigator.serviceWorker || !serviceWorkerRelativeUrl) {
         return null;
     }
-    const { name, version } = get_browser();
+    const { name, version } = getBrowser();
     if (name === 'chrome' && parseInt(version) < 90) {
         return null;
     }
@@ -90,6 +160,8 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
         return null;
     }
 
+   const operatingSystem = getOperatingSystem();
+
     const registration = await navigator.serviceWorker.register(serviceWorkerRelativeUrl);
 
     try {
@@ -98,19 +170,32 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
         return null;
     }
 
-    const saveItemsAsync = (items) => {
-            return sendMessageAsync(registration)({ type: 'saveItems', data: items, configurationName });
+    const unregisterAsync = async () => {
+        return await registration.unregister();
     };
 
+    const saveItemsAsync = (items) => {
+        // iOS kill Service Worker when domain we leave domain
+        if (operatingSystem.os === 'iOS') {
+            const session = initSession(configurationName, redirectUri);
+            return session.saveItemsAsync(items);
+        }
+        return sendMessageAsync(registration)({ type: 'saveItems', data: items, configurationName });
+    };
     const loadItemsAsync = () => {
+        // iOS kill Service Worker when domain we leave domain
+        if (operatingSystem.os === 'iOS') {
+            const session = initSession(configurationName, redirectUri);
+            return session.loadItemsAsync();
+        }
         return sendMessageAsync(registration)({ type: 'loadItems', data: null, configurationName });
     };
-
-    const unregisterAsync = async () => {
-        return await registration.unregister();
-    };
-
-    const clearAsync = (status) => {
+    const clearAsync = async (status) => {
+        // iOS kill Service Worker when domain we leave domain
+        if (operatingSystem.os === 'iOS') {
+            const session = initSession(configurationName, redirectUri);
+            await session.clearAsync(status);
+        }
         return sendMessageAsync(registration)({ type: 'clear', data: { status }, configurationName });
     };
     const initAsync = async (oidcServerConfiguration, where, oidcConfiguration:OidcConfiguration) => {
@@ -141,10 +226,21 @@ export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName
     };
 
     const setNonceAsync = (nonce) => {
+        // iOS kill Service Worker when domain we leave domain
+        if (operatingSystem.os === 'iOS') {
+            const session = initSession(configurationName, redirectUri);
+            return session.setNonceAsync(nonce);
+        }
         return sendMessageAsync(registration)({ type: 'setNonce', data: { nonce }, configurationName });
     };
+
     const NONCE_TOKEN = 'NONCE_SECURED_BY_OIDC_SERVICE_WORKER';
     const getNonceAsync = async () => {
+        // iOS kill Service Worker when domain we leave domain
+        if (operatingSystem.os === 'iOS') {
+            const session = initSession(configurationName, redirectUri);
+            return session.getNonceAsync();
+        }
         // @ts-ignore
         const keyNonce = NONCE_TOKEN + '_' + configurationName;
         return { nonce: keyNonce };

package/src/oidc/vanilla/oidc.ts

@@ -33,7 +33,7 @@ const TOKEN_TYPE = {
     access_token: 'access_token',
 };
 
-const performRevocationRequestAsync = async (url, token, token_type = TOKEN_TYPE.refresh_token, client_id) => {
+const performRevocationRequestAsync = async (url, token, token_type = TOKEN_TYPE.refresh_token, client_id, timeoutMs = 10000) => {
     const details = {
         token,
         token_type_hint: token_type,
@@ -54,7 +54,7 @@ const performRevocationRequestAsync = async (url, token, token_type = TOKEN_TYPE
             'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
         },
         body: formBodyString,
-    });
+    }, timeoutMs);
     if (response.status !== 200) {
         return { success: false };
     }
@@ -63,7 +63,7 @@ const performRevocationRequestAsync = async (url, token, token_type = TOKEN_TYPE
     };
 };
 
-const performTokenRequestAsync = async (url, details, extras, oldTokens, tokenRenewMode: string) => {
+const performTokenRequestAsync = async (url, details, extras, oldTokens, tokenRenewMode: string, timeoutMs = 10000) => {
     for (const [key, value] of Object.entries(extras)) {
         if (details[key] === undefined) {
             details[key] = value;
@@ -84,7 +84,7 @@ const performTokenRequestAsync = async (url, details, extras, oldTokens, tokenRe
             'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
         },
         body: formBodyString,
-    });
+    }, timeoutMs);
     if (response.status !== 200) {
         return { success: false, status: response.status };
     }
@@ -95,17 +95,17 @@ const performTokenRequestAsync = async (url, details, extras, oldTokens, tokenRe
     };
 };
 
-const internalFetch = async (url, headers, numberRetry = 0) => {
+const internalFetch = async (url, headers, numberRetry = 0, timeoutMs = 10000) => {
     let response;
     try {
         const controller = new AbortController();
-        setTimeout(() => controller.abort(), 10000);
+        setTimeout(() => controller.abort(), timeoutMs);
         response = await fetch(url, { ...headers, signal: controller.signal });
     } catch (e) {
         if (e.message === 'AbortError' ||
             e.message === 'Network request failed') {
             if (numberRetry <= 1) {
-                return await internalFetch(url, headers, numberRetry + 1);
+                return await internalFetch(url, headers, numberRetry + 1, timeoutMs);
             } else {
                 throw e;
             }
@@ -208,7 +208,7 @@ async function renewTokensAndStartTimerAsync(oidc, refreshToken, forceRefresh =
     const updateTokens = (tokens) => { oidc.tokens = tokens; };
     const { tokens, status } = await oidc.synchroniseTokensAsync(refreshToken, 0, forceRefresh, extras, updateTokens);
 
-    const serviceWorker = await initWorkerAsync(oidc.configuration.service_worker_relative_url, oidc.configurationName);
+    const serviceWorker = await initWorkerAsync(oidc.configuration.service_worker_relative_url, oidc.configurationName, oidc.configuration.redirect_uri);
     if (!serviceWorker) {
         const session = initSession(oidc.configurationName, oidc.configuration.redirect_uri, oidc.configuration.storage);
         await session.setTokens(oidc.tokens);
@@ -565,7 +565,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                 });
             }
 
-            const serviceWorker = await initWorkerAsync(this.configuration.service_worker_relative_url, this.configurationName);
+            const serviceWorker = await initWorkerAsync(this.configuration.service_worker_relative_url, this.configurationName, this.configuration.redirect_uri);
             const storage = serviceWorker ? window.localStorage : null;
             return await fetchFromIssuer(authority, this.configuration.authority_time_cache_wellknowurl_in_second ?? 60 * 60, storage);
         };
@@ -590,7 +590,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             try {
                 const configuration = this.configuration;
                 const oidcServerConfiguration = await this.initAsync(configuration.authority, configuration.authority_configuration);
-                serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, this.configurationName);
+                serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, this.configurationName, configuration.redirect_uri);
                 if (serviceWorker) {
                     const { tokens } = await serviceWorker.initAsync(oidcServerConfiguration, 'tryKeepExistingSessionAsync', configuration);
                     if (tokens) {
@@ -704,7 +704,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                     extraFinal.nonce = randomString(12);
                 }
                 const nonce = { nonce: extraFinal.nonce };
-                const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, this.configurationName);
+                const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, this.configurationName, this.configuration.redirect_uri);
                 const oidcServerConfiguration = await this.initAsync(configuration.authority, configuration.authority_configuration);
                 let storage;
                 if (serviceWorker) {
@@ -777,13 +777,9 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
                     }).catch(async (e) => {
                         // eslint-disable-next-line @typescript-eslint/no-unused-vars
                         for (const [key, oidc] of Object.entries(oidcDatabase)) {
-                            // if(oidc !== this) {
-                                // @ts-ignore
-                               await oidc.logoutOtherTabAsync(this.configuration.client_id, idTokenPayload.sub);
-                            // }
+                            // @ts-ignore
+                            await oidc.logoutOtherTabAsync(this.configuration.client_id, idTokenPayload.sub);
                         }
-                        // await this.destroyAsync();
-                        // this.publishEvent(eventNames.logout_from_another_tab, {message : "SessionMonitor"});
                     });
                 };
 
@@ -812,7 +808,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             const parsedTokens = response.tokens;
             // @ts-ignore
             this.tokens = response.tokens;
-            const serviceWorker = await initWorkerAsync(this.configuration.service_worker_relative_url, this.configurationName);
+            const serviceWorker = await initWorkerAsync(this.configuration.service_worker_relative_url, this.configurationName, this.configuration.redirect_uri);
             if (!serviceWorker) {
                 const session = initSession(this.configurationName, this.configuration.redirect_uri, this.configuration.storage);
                 session.setTokens(parsedTokens);
@@ -839,7 +835,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             const oidcServerConfiguration = await this.initAsync(authority, configuration.authority_configuration);
             const queryParams = getParseQueryStringFromLocation(window.location.href);
             const sessionState = queryParams.session_state;
-            const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, this.configurationName);
+            const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, this.configurationName, configuration.redirect_uri);
             let storage = null;
             let nonceData = null;
             if (serviceWorker) {
@@ -963,6 +959,10 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
     }
 
     async synchroniseTokensAsync(refreshToken, index = 0, forceRefresh = false, extras:StringMap = null, updateTokens) {
+        while (!navigator.onLine && document.hidden) {
+            await sleepAsync(1000);
+            this.publishEvent(eventNames.refreshTokensAsync, { message: 'wait because navigator is offline and hidden' });
+        }
         let numberTryOnline = 6;
         while (!navigator.onLine && numberTryOnline > 0) {
             await sleepAsync(1000);
@@ -1012,68 +1012,78 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
             this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token' });
             return { tokens: null, status: 'SESSION_LOST' };
         }
-        const { status, tokens, nonce } = await this.syncTokensInfoAsync(configuration, this.configurationName, this.tokens, forceRefresh);
-        switch (status) {
-            case 'SESSION_LOST':
-                updateTokens(null);
-                this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token session lost' });
-                return { tokens: null, status: 'SESSION_LOST' };
-            case 'NOT_CONNECTED':
-                updateTokens(null);
-                return { tokens: null, status: null };
-            case 'TOKENS_VALID':
-                updateTokens(tokens);
-                return { tokens, status: 'LOGGED_IN' };
-            case 'TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID':
-                updateTokens(tokens);
-                this.publishEvent(Oidc.eventNames.token_renewed, { reason: 'TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID' });
-                return { tokens, status: 'LOGGED_IN' };
-            case 'LOGOUT_FROM_ANOTHER_TAB':
-                updateTokens(null);
-                this.publishEvent(eventNames.logout_from_another_tab, { status: 'session syncTokensAsync' });
-                return { tokens: null, status: 'LOGGED_OUT' };
-            case 'REQUIRE_SYNC_TOKENS':
-                this.publishEvent(eventNames.refreshTokensAsync_begin, { refreshToken, status, tryNumber: index });
-                return await localsilentLoginAsync();
-            default: {
-                if (!refreshToken) {
+        try {
+            const { status, tokens, nonce } = await this.syncTokensInfoAsync(configuration, this.configurationName, this.tokens, forceRefresh);
+            switch (status) {
+                case 'SESSION_LOST':
+                    updateTokens(null);
+                    this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token session lost' });
+                    return { tokens: null, status: 'SESSION_LOST' };
+                case 'NOT_CONNECTED':
+                    updateTokens(null);
+                    return { tokens: null, status: null };
+                case 'TOKENS_VALID':
+                    updateTokens(tokens);
+                    return { tokens, status: 'LOGGED_IN' };
+                case 'TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID':
+                    updateTokens(tokens);
+                    this.publishEvent(Oidc.eventNames.token_renewed, { reason: 'TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID' });
+                    return { tokens, status: 'LOGGED_IN' };
+                case 'LOGOUT_FROM_ANOTHER_TAB':
+                    updateTokens(null);
+                    this.publishEvent(eventNames.logout_from_another_tab, { status: 'session syncTokensAsync' });
+                    return { tokens: null, status: 'LOGGED_OUT' };
+                case 'REQUIRE_SYNC_TOKENS':
+                    this.publishEvent(eventNames.refreshTokensAsync_begin, { refreshToken, status, tryNumber: index });
                     return await localsilentLoginAsync();
-                }
-                this.publishEvent(eventNames.refreshTokensAsync_begin, { refreshToken, status, tryNumber: index });
-
-                const clientId = configuration.client_id;
-                const redirectUri = configuration.redirect_uri;
-                const authority = configuration.authority;
-                const tokenExtras = configuration.token_request_extras ? configuration.token_request_extras : {};
-                const finalExtras = { ...tokenExtras, ...extras };
-
-                const details = {
-                    client_id: clientId,
-                    redirect_uri: redirectUri,
-                    grant_type: GRANT_TYPE_REFRESH_TOKEN,
-                    refresh_token: tokens.refreshToken,
-                };
-                const oidcServerConfiguration = await this.initAsync(authority, configuration.authority_configuration);
-                const tokenResponse = await performTokenRequestAsync(oidcServerConfiguration.tokenEndpoint, details, finalExtras, tokens, configuration.token_renew_mode);
-                if (tokenResponse.success) {
-                    if (!isTokensOidcValid(tokenResponse.data, nonce.nonce, oidcServerConfiguration)) {
-                        updateTokens(null);
-                        this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token return not valid tokens' });
-                        return { tokens: null, status: 'SESSION_LOST' };
+                default: {
+                    this.publishEvent(eventNames.refreshTokensAsync_begin, { refreshToken, status, tryNumber: index });
+                    if (!refreshToken) {
+                        return await localsilentLoginAsync();
                     }
-                    updateTokens(tokenResponse.data);
-                    this.publishEvent(eventNames.refreshTokensAsync_end, { success: tokenResponse.success });
-                    this.publishEvent(Oidc.eventNames.token_renewed, { reason: 'REFRESH_TOKEN' });
-                    return { tokens: tokenResponse.data, status: 'LOGGED_IN' };
-                } else {
-                    this.publishEvent(eventNames.refreshTokensAsync_silent_error, {
-                        message: 'bad request',
-                        tokenResponse,
-                    });
-                    return await this.synchroniseTokensAsync(null, nextIndex, forceRefresh, extras, updateTokens);
+
+                    const clientId = configuration.client_id;
+                    const redirectUri = configuration.redirect_uri;
+                    const authority = configuration.authority;
+                    const tokenExtras = configuration.token_request_extras ? configuration.token_request_extras : {};
+                    const finalExtras = { ...tokenExtras, ...extras };
+                    const localFunctionAsync = async () => {
+                        const details = {
+                            client_id: clientId,
+                            redirect_uri: redirectUri,
+                            grant_type: GRANT_TYPE_REFRESH_TOKEN,
+                            refresh_token: tokens.refreshToken,
+                        };
+                        const oidcServerConfiguration = await this.initAsync(authority, configuration.authority_configuration);
+                        const timeoutMs = document.hidden ? 10000 : 30000 * 10;
+                        const tokenResponse = await performTokenRequestAsync(oidcServerConfiguration.tokenEndpoint, details, finalExtras, tokens, configuration.token_renew_mode, timeoutMs);
+                        if (tokenResponse.success) {
+                            if (!isTokensOidcValid(tokenResponse.data, nonce.nonce, oidcServerConfiguration)) {
+                                updateTokens(null);
+                                this.publishEvent(eventNames.refreshTokensAsync_error, { message: 'refresh token return not valid tokens' });
+                                return { tokens: null, status: 'SESSION_LOST' };
+                            }
+                            updateTokens(tokenResponse.data);
+                            this.publishEvent(eventNames.refreshTokensAsync_end, { success: tokenResponse.success });
+                            this.publishEvent(Oidc.eventNames.token_renewed, { reason: 'REFRESH_TOKEN' });
+                            return { tokens: tokenResponse.data, status: 'LOGGED_IN' };
+                        } else {
+                            this.publishEvent(eventNames.refreshTokensAsync_silent_error, {
+                                message: 'bad request',
+                                tokenResponse,
+                            });
+                            return await this.synchroniseTokensAsync(refreshToken, nextIndex, forceRefresh, extras, updateTokens);
+                        }
+                    };
+                    // const promise =
+                    return await localFunctionAsync(); // executeWithTimeoutAsync(promise, 30000);
                 }
             }
-        }
+        } catch (exception) {
+                console.error(exception);
+                this.publishEvent(eventNames.refreshTokensAsync_silent_error, { message: 'exception', exception: exception.message });
+                return this.synchroniseTokensAsync(refreshToken, nextIndex, forceRefresh, extras, updateTokens);
+            }
      }
 
     async syncTokensInfoAsync(configuration, configurationName, currentTokens, forceRefresh = false) {
@@ -1085,7 +1095,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
         }
         let nonce = nullNonce;
         const oidcServerConfiguration = await this.initAsync(configuration.authority, configuration.authority_configuration);
-        const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, configurationName);
+        const serviceWorker = await initWorkerAsync(configuration.service_worker_relative_url, configurationName, configuration.redirect_uri);
         if (serviceWorker) {
             const { status, tokens } = await serviceWorker.initAsync(oidcServerConfiguration, 'syncTokensAsync', configuration);
             if (status === 'LOGGED_OUT') {
@@ -1164,7 +1174,7 @@ Please checkout that you are using OIDC hook inside a <OidcProvider configuratio
          if (this.checkSessionIFrame) {
              this.checkSessionIFrame.stop();
          }
-         const serviceWorker = await initWorkerAsync(this.configuration.service_worker_relative_url, this.configurationName);
+         const serviceWorker = await initWorkerAsync(this.configuration.service_worker_relative_url, this.configurationName, this.configuration.redirect_uri);
          if (!serviceWorker) {
              const session = initSession(this.configurationName, this.configuration.redirect_uri, this.configuration.storage);
              await session.clearAsync(status);