@axa-fr/react-oidc 6.6.0 → 6.6.2-alpha0

package/src/oidc/vanilla/checkSessionIFrame.ts

@@ -0,0 +1,82 @@
+const DefaultInterval = 2000;
+
+const Log = console;
+
+export class CheckSessionIFrame {
+    private readonly _client_id: any;
+    private readonly _callback: any;
+    private _url: any;
+    private readonly _interval: number;
+    private readonly _stopOnError: boolean;
+    private readonly _frame_origin: string;
+    private readonly _frame: HTMLIFrameElement;
+    private _boundMessageEvent: any;
+    private _timer: number;
+    constructor(callback, client_id, url, interval=DefaultInterval, stopOnError = true) {
+        this._callback = callback;
+        this._client_id = client_id;
+        this._url = url;
+        this._interval = interval || DefaultInterval;
+        this._stopOnError = stopOnError;
+        const idx = url.indexOf("/", url.indexOf("//") + 2);
+        this._frame_origin = url.substr(0, idx);
+        this._frame = window.document.createElement("iframe");
+        this._frame.style.visibility = "hidden";
+        this._frame.style.position = "absolute";
+        this._frame.style.display = "none";
+        // @ts-ignore
+        this._frame.width = 0;
+        // @ts-ignore
+        this._frame.height = 0;
+
+        this._frame.src = url;
+    }
+    load() {
+        return new Promise<void>((resolve) => {
+            this._frame.onload = () => {
+                resolve();
+            }
+            window.document.body.appendChild(this._frame);
+            this._boundMessageEvent = this._message.bind(this);
+            window.addEventListener("message", this._boundMessageEvent, false);
+        });
+    }
+    _message(e) {
+        if (e.origin === this._frame_origin &&
+            e.source === this._frame.contentWindow
+        ) {
+            if (e.data === "error") {
+                Log.error("CheckSessionIFrame: error message from check session op iframe");
+                if (this._stopOnError) {
+                    this.stop();
+                }
+            }
+            else if (e.data === "changed") {
+                Log.debug(e)
+                Log.debug("CheckSessionIFrame: changed message from check session op iframe");
+                this.stop();
+                this._callback();
+            }
+            else {
+                Log.debug("CheckSessionIFrame: " + e.data + " message from check session op iframe");
+            }
+        }
+    }
+    start(session_state) {
+            Log.debug("CheckSessionIFrame.start :" + session_state);
+            this.stop();
+            let send = () => {
+                this._frame.contentWindow.postMessage(this._client_id + " " + session_state, this._frame_origin);
+            };
+            send();
+            this._timer = window.setInterval(send, this._interval);
+    }
+
+    stop() {
+        if (this._timer) {
+            Log.debug("CheckSessionIFrame.stop");
+            window.clearInterval(this._timer);
+            this._timer = null;
+        }
+    }
+}

package/src/oidc/vanilla/index.ts

@@ -0,0 +1 @@
+export { Oidc } from './oidc';

package/src/oidc/vanilla/initSession.ts

@@ -0,0 +1,67 @@
+export const initSession = (configurationName, redirectUri, storage=sessionStorage) => {
+
+    const saveItemsAsync =(items) =>{
+        storage[`oidc_items.${configurationName}:${redirectUri}`] = JSON.stringify(items);
+        return Promise.resolve();
+    }
+
+    const loadItemsAsync=() =>{
+        return Promise.resolve(JSON.parse(storage[`oidc_items.${configurationName}:${redirectUri}`]));
+    }
+
+    const clearAsync=(status) =>{
+        storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({tokens:null, status});
+        return Promise.resolve();
+    }
+
+    const initAsync=async () => {
+        if(!storage[`oidc.${configurationName}:${redirectUri}`]){
+            storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({tokens:null, status:null});
+            return {tokens:null, status:null};
+        }
+        const data = JSON.parse(storage[`oidc.${configurationName}:${redirectUri}`]);
+        return Promise.resolve({ tokens : data.tokens, status: data.status });
+    }
+
+    const setTokens = (tokens) => {
+        storage[`oidc.${configurationName}:${redirectUri}`] = JSON.stringify({tokens});
+    }
+
+    const setSessionState = (sessionState) => {
+        storage[`oidc.session_state.${configurationName}:${redirectUri}`] = sessionState;
+    }
+    
+    const getSessionState= () =>{
+        return storage[`oidc.session_state.${configurationName}:${redirectUri}`];
+    }
+
+    const setNonceAsync = (nonce) => {
+        localStorage[`oidc.nonce.${configurationName}:${redirectUri}`] = nonce.nonce;
+    }
+
+    const getNonceAsync= async () => {
+        // @ts-ignore
+        const result =  {nonce: localStorage[`oidc.nonce.${configurationName}:${redirectUri}`]};
+        return result;
+    }
+
+    const getTokens = () => {
+        if(!storage[`oidc.${configurationName}:${redirectUri}`]){
+            return null;
+        }
+        return JSON.stringify({ tokens : JSON.parse(storage[`oidc.${configurationName}:${redirectUri}`]).tokens });
+    }
+
+    return {
+        saveItemsAsync, 
+        loadItemsAsync, 
+        clearAsync, 
+        initAsync, 
+        setTokens, 
+        getTokens, 
+        setSessionState, 
+        getSessionState,
+        setNonceAsync,
+        getNonceAsync
+    };
+}

package/src/oidc/vanilla/initWorker.ts

@@ -0,0 +1,165 @@
+import timer from "./timer"
+import {parseOriginalTokens} from "./parseTokens";
+
+function get_browser() {
+    let ua = navigator.userAgent, tem,
+        M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
+    if(/trident/i.test(M[1])){
+        tem=/\brv[ :]+(\d+)/g.exec(ua) || [];
+        return {name:'ie',version:(tem[1]||'')};
+    }
+    if(M[1]==='Chrome'){
+        tem=ua.match(/\bOPR|Edge\/(\d+)/);
+       
+        if(tem!=null) {
+            let version = tem[1];
+            if(!version){
+                const splits = ua.split(tem[0]+"/");
+                if(splits.length>1){
+                    version = splits[1];
+                }
+            }
+            
+            return {name:'opera', version};
+        }
+    }
+    M=M[2]? [M[1], M[2]]: [navigator.appName, navigator.appVersion, '-?'];
+    if((tem=ua.match(/version\/(\d+)/i))!=null) {M.splice(1,1,tem[1]);}
+    return {
+        name: M[0].toLowerCase(),
+        version: M[1]
+    };
+}
+
+let keepAliveServiceWorkerTimeoutId = null;
+
+export const sleepAsync = (milliseconds) => {
+    return new Promise(resolve => timer.setTimeout(resolve, milliseconds))
+}
+
+const keepAlive = () => {
+    fetch('/OidcKeepAliveServiceWorker.json');
+    sleepAsync(230*1000).then(keepAlive);
+}
+
+const isServiceWorkerProxyActiveAsync = () => {
+    return fetch('/OidcKeepAliveServiceWorker.json', {
+        headers: {
+            'oidc-vanilla': "true"
+        }})
+        .then((response) => {
+            return response.statusText === 'oidc-service-worker';
+        });
+};
+
+const sendMessageAsync = (registration) => (data) =>{
+    return new Promise(function(resolve, reject) {
+        const messageChannel = new MessageChannel();
+        messageChannel.port1.onmessage = function (event) {
+            if (event.data && event.data.error) {
+                reject(event.data.error);
+            } else {
+                resolve(event.data);
+            }
+        };
+        registration.active.postMessage(data, [messageChannel.port2]);
+    });
+}
+
+export const initWorkerAsync = async(serviceWorkerRelativeUrl, configurationName) => {
+    
+    if(typeof window === "undefined" || typeof navigator === "undefined" || !navigator.serviceWorker||!serviceWorkerRelativeUrl){
+        return null;
+    }
+    const {name, version} = get_browser();
+    if(name == "chrome" && parseInt(version)<90){
+        return null;
+    }
+    if(name == "opera"){
+        if(!version) {
+            return null;
+        }
+        if(parseInt(version.split(".")[0])< 80) {
+            return null;
+        }
+    }
+    if(name == "ie"){
+        return null;
+    }
+
+    const registration = await navigator.serviceWorker.register(serviceWorkerRelativeUrl);
+
+    try {
+        await navigator.serviceWorker.ready
+    }
+    catch(err) {
+        return null;
+    }
+    
+    const saveItemsAsync =(items) =>{
+            return sendMessageAsync(registration)({type: "saveItems", data: items, configurationName});
+    }
+    
+    const loadItemsAsync=() =>{
+        return sendMessageAsync(registration)({type: "loadItems", data: null, configurationName});
+    }
+    
+    const unregisterAsync = async () => {
+        return await registration.unregister();
+    }
+    
+    const clearAsync=(status) =>{
+        return sendMessageAsync(registration)({type: "clear", data: {status}, configurationName});
+    }
+    const initAsync= async (oidcServerConfiguration, where) => {
+        const result = await sendMessageAsync(registration)({
+            type: "init",
+            data: {oidcServerConfiguration, where},
+            configurationName
+        });
+        // @ts-ignore
+        return { tokens : parseOriginalTokens(result.tokens, null), status: result.status};
+    }
+    
+    const startKeepAliveServiceWorker = () => {
+        if (keepAliveServiceWorkerTimeoutId == null) {
+            keepAliveServiceWorkerTimeoutId = "not_null";
+            keepAlive();
+        }
+    }
+
+    const setSessionStateAsync = (sessionState) => {
+        return sendMessageAsync(registration)({type: "setSessionState", data: {sessionState}, configurationName});
+    }
+
+    const getSessionStateAsync= async () => {
+        const result = await sendMessageAsync(registration)({type: "getSessionState", data: null, configurationName});
+        // @ts-ignore
+        return result.sessionState;
+    }
+
+    const setNonceAsync = (nonce) => {
+        return sendMessageAsync(registration)({type: "setNonce", data: {nonce}, configurationName});
+    }
+    const NONCE_TOKEN = 'NONCE_SECURED_BY_OIDC_SERVICE_WORKER';
+    const getNonceAsync= async () => {
+        // @ts-ignore
+        const keyNonce = NONCE_TOKEN + '_'+ configurationName;
+        return {nonce:keyNonce};
+    }
+
+    return { 
+        saveItemsAsync, 
+        loadItemsAsync, 
+        clearAsync, 
+        initAsync, 
+       // getAccessTokenPayloadAsync,
+        startKeepAliveServiceWorker,
+        isServiceWorkerProxyActiveAsync,
+        setSessionStateAsync,
+        getSessionStateAsync,
+        setNonceAsync,
+        getNonceAsync,
+        unregisterAsync,
+    };
+}

package/src/oidc/vanilla/memoryStorageBackend.ts

@@ -0,0 +1,33 @@
+export class MemoryStorageBackend {
+    public items: any;
+    private saveItemsAsync: Function;
+
+    constructor(saveItemsAsync, items = {}) {
+        this.items = items;
+        this.saveItemsAsync = saveItemsAsync;
+        this.saveItemsAsync.bind(this);
+        this.getItem.bind(this);
+        this.removeItem.bind(this);
+        this.clear.bind(this);
+        this.setItem.bind(this);
+    }
+
+    getItem(name) {
+        return Promise.resolve(this.items[name]);
+    }
+
+    removeItem(name) {
+        delete this.items[name];
+        return this.saveItemsAsync(this.items);
+    }
+
+    clear() {
+        this.items = {};
+        return this.saveItemsAsync(this.items);
+    }
+
+    setItem(name, value) {
+        this.items[name] = value;
+        return this.saveItemsAsync(this.items);
+    }
+}

package/src/oidc/vanilla/noHashQueryStringUtils.ts

@@ -0,0 +1,33 @@
+import {BasicQueryStringUtils} from '@openid/appauth';
+
+export class NoHashQueryStringUtils extends BasicQueryStringUtils {
+    parse(input, useHash) {
+        const output = super.parse(input, false /* never use hash */);
+        return output;
+    }
+}
+
+const keys = ["code", "session_state", "state"]
+
+export class HashQueryStringUtils extends BasicQueryStringUtils {
+    parse(input, useHash) {
+        const output =  super.parse(input, true /* use hash */);
+        
+        // Fix AppAuthJs behavior
+        let propertyToDelelete = null;
+        Object.entries(output).map(([key, value]) => {
+            keys.forEach(k => {
+                if(key.endsWith(`?${k}`)){
+                    output[k]= value;
+                    propertyToDelelete = key;
+                }
+            })
+        });
+        
+        if(propertyToDelelete){
+            delete output[propertyToDelelete];
+        }
+        
+        return output;
+    }
+}