7775532556

Committed 04 Feb 2024 05:04PM UTC coverage: 92.564% (-4.5%) from 97.057%

Build # 7775532556

Build Type

Pull #1848

github

Committed by

web-flow

Commit Message

Merge 873979cee into d4d613e6d

Pull Request Pull Request #1848: moving to strict mode

Run Details

695 of 818 branches covered (0.0%)

Branch coverage included in aggregate %.

217 of 290 new or added lines in 48 files covered. (74.83%)

11 existing lines in 6 files now uncovered.

2554 of 2692 relevant lines covered (94.87%)

8.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.43

/projects/angular-auth-oidc-client/src/lib/iframe/check-session.service.ts

import { DOCUMENT } from '@angular/common';
import { Inject, Injectable, NgZone, OnDestroy } from '@angular/core';
import { BehaviorSubject, Observable, of } from 'rxjs';
import { take } from 'rxjs/operators';
import { OpenIdConfiguration } from '../config/openid-configuration';
import { LoggerService } from '../logging/logger.service';
import { EventTypes } from '../public-events/event-types';
import { PublicEventsService } from '../public-events/public-events.service';
import { StoragePersistenceService } from '../storage/storage-persistence.service';
import { IFrameService } from './existing-iframe.service';

const IFRAME_FOR_CHECK_SESSION_IDENTIFIER = 'myiFrameForCheckSession';

// http://openid.net/specs/openid-connect-session-1_0-ID4.html

@Injectable({ providedIn: 'root' })
export class CheckSessionService implements OnDestroy {
  private checkSessionReceived = false;

  private scheduledHeartBeatRunning: any;

  private lastIFrameRefresh = 0;

  private outstandingMessages = 0;

  private readonly heartBeatInterval = 3000;

  private readonly iframeRefreshInterval = 60000;

  private readonly checkSessionChangedInternal$ = new BehaviorSubject<boolean>(
    false
  );

  private iframeMessageEventListener: any;

  get checkSessionChanged$(): Observable<boolean> {
    return this.checkSessionChangedInternal$.asObservable();
  }

  constructor(
    private readonly storagePersistenceService: StoragePersistenceService,
    private readonly loggerService: LoggerService,
    private readonly iFrameService: IFrameService,
    private readonly eventService: PublicEventsService,
    private readonly zone: NgZone,
    @Inject(DOCUMENT) private readonly document: Document
  ) {}

  ngOnDestroy(): void {
    this.stop();
    const windowAsDefaultView = this.document.defaultView;

    if (windowAsDefaultView) {
      windowAsDefaultView.removeEventListener(
        'message',
        this.iframeMessageEventListener,
        false
      );
    }
  }

  isCheckSessionConfigured(configuration: OpenIdConfiguration): boolean {
    const { startCheckSession } = configuration;

    return Boolean(startCheckSession);
  }

  start(configuration: OpenIdConfiguration): void {
    if (!!this.scheduledHeartBeatRunning) {
      return;
    }

    const { clientId } = configuration;

    this.pollServerSession(clientId, configuration);
  }

  stop(): void {
    if (!this.scheduledHeartBeatRunning) {
      return;
    }

    this.clearScheduledHeartBeat();
    this.checkSessionReceived = false;
  }

  serverStateChanged(configuration: OpenIdConfiguration): boolean {
    const { startCheckSession } = configuration;

    return Boolean(startCheckSession) && this.checkSessionReceived;
  }

  getExistingIframe(): HTMLIFrameElement | null {
    return this.iFrameService.getExistingIFrame(
      IFRAME_FOR_CHECK_SESSION_IDENTIFIER
    );
  }

  private init(configuration: OpenIdConfiguration): Observable<any> {
    if (this.lastIFrameRefresh + this.iframeRefreshInterval > Date.now()) {
      return of(undefined);
    }

    const authWellKnownEndPoints = this.storagePersistenceService.read(
      'authWellKnownEndPoints',
      configuration
    );

    if (!authWellKnownEndPoints) {
      this.loggerService.logWarning(
        configuration,
        'CheckSession - init check session: authWellKnownEndpoints is undefined. Returning.'
      );

      return of();
    }

    const existingIframe = this.getOrCreateIframe(configuration);

    // https://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html#Events-EventTarget-addEventListener
    // If multiple identical EventListeners are registered on the same EventTarget with the same parameters the duplicate instances are discarded. They do not cause the EventListener to be called twice and since they are discarded they do not need to be removed with the removeEventListener method.
    // this is done even if iframe exists for HMR to work, since iframe exists on service init
    this.bindMessageEventToIframe(configuration);
    const checkSessionIframe = authWellKnownEndPoints.checkSessionIframe;
    const contentWindow = existingIframe.contentWindow;

    if (!checkSessionIframe) {
      this.loggerService.logWarning(
        configuration,
        'CheckSession - init check session: checkSessionIframe is not configured to run'
      );
    }

    if (!contentWindow) {
      this.loggerService.logWarning(
        configuration,
        'CheckSession - init check session: IFrame contentWindow does not exist'
      );
    } else {
      contentWindow.location.replace(checkSessionIframe);
    }

    return new Observable((observer) => {
      existingIframe.onload = (): void => {
        this.lastIFrameRefresh = Date.now();
        observer.next();
        observer.complete();
      };
    });
  }

  private pollServerSession(
    clientId: string | undefined,
    configuration: OpenIdConfiguration
  ): void {
    this.outstandingMessages = 0;

    const pollServerSessionRecur = (): void => {
      this.init(configuration)
        .pipe(take(1))
        .subscribe(() => {
          const existingIframe = this.getExistingIframe();

          if (existingIframe && clientId) {
            this.loggerService.logDebug(
              configuration,
              `CheckSession - clientId : '${clientId}' - existingIframe: '${existingIframe}'`
            );
            const sessionState = this.storagePersistenceService.read(
              'session_state',
              configuration
            );
            const authWellKnownEndPoints = this.storagePersistenceService.read(
              'authWellKnownEndPoints',
              configuration
            );
            const contentWindow = existingIframe.contentWindow;

            if (
              sessionState &&
              authWellKnownEndPoints?.checkSessionIframe &&
              contentWindow
            ) {
              const iframeOrigin = new URL(
                authWellKnownEndPoints.checkSessionIframe
              )?.origin;

              this.outstandingMessages++;
              contentWindow.postMessage(
                clientId + ' ' + sessionState,
                iframeOrigin
              );
            } else {
              this.loggerService.logDebug(
                configuration,
                `CheckSession - session_state is '${sessionState}' - AuthWellKnownEndPoints is '${JSON.stringify(
                  authWellKnownEndPoints,
                  null,
                  2
                )}'`
              );
              this.checkSessionChangedInternal$.next(true);
            }
          } else {
            this.loggerService.logWarning(
              configuration,
              `CheckSession - OidcSecurityCheckSession pollServerSession checkSession IFrame does not exist:
               clientId : '${clientId}' - existingIframe: '${existingIframe}'`
            );
          }

          // after sending three messages with no response, fail.
          if (this.outstandingMessages > 3) {
            this.loggerService.logError(
              configuration,
              `CheckSession - OidcSecurityCheckSession not receiving check session response messages.
                            Outstanding messages: '${this.outstandingMessages}'. Server unreachable?`
            );
          }

          this.zone.runOutsideAngular(() => {
            this.scheduledHeartBeatRunning = setTimeout(
              () => this.zone.run(pollServerSessionRecur),
              this.heartBeatInterval
            );
          });
        });
    };

    pollServerSessionRecur();
  }

  private clearScheduledHeartBeat(): void {
    clearTimeout(this.scheduledHeartBeatRunning);
    this.scheduledHeartBeatRunning = null;
  }

  private messageHandler(configuration: OpenIdConfiguration, e: any): void {
    const existingIFrame = this.getExistingIframe();
    const authWellKnownEndPoints = this.storagePersistenceService.read(
      'authWellKnownEndPoints',
      configuration
    );
    const startsWith = !!authWellKnownEndPoints?.checkSessionIframe?.startsWith(
      e.origin
    );

    this.outstandingMessages = 0;

    if (
      existingIFrame &&
      startsWith &&
      e.source === existingIFrame.contentWindow
    ) {
      if (e.data === 'error') {
        this.loggerService.logWarning(
          configuration,
          'CheckSession - error from check session messageHandler'
        );
      } else if (e.data === 'changed') {
        this.loggerService.logDebug(
          configuration,
          `CheckSession - ${e} from check session messageHandler`
        );
        this.checkSessionReceived = true;
        this.eventService.fireEvent(EventTypes.CheckSessionReceived, e.data);
        this.checkSessionChangedInternal$.next(true);
      } else {
        this.eventService.fireEvent(EventTypes.CheckSessionReceived, e.data);
        this.loggerService.logDebug(
          configuration,
          `CheckSession - ${e.data} from check session messageHandler`
        );
      }
    }
  }

  private bindMessageEventToIframe(configuration: OpenIdConfiguration): void {
    this.iframeMessageEventListener = this.messageHandler.bind(
      this,
      configuration
    );

    const defaultView = this.document.defaultView;

    if (defaultView) {
      defaultView.addEventListener(
        'message',
        this.iframeMessageEventListener,
        false
      );
    }
  }

  private getOrCreateIframe(
    configuration: OpenIdConfiguration
  ): HTMLIFrameElement {
    return (
      this.getExistingIframe() ||
      this.iFrameService.addIFrameToWindowBody(
        IFRAME_FOR_CHECK_SESSION_IDENTIFIER,
        configuration
      )
    );
  }
}

1	import { DOCUMENT } from '@angular/common';
2	import { Inject, Injectable, NgZone, OnDestroy } from '@angular/core';
3	import { BehaviorSubject, Observable, of } from 'rxjs';
4	import { take } from 'rxjs/operators';
5	import { OpenIdConfiguration } from '../config/openid-configuration';
6	import { LoggerService } from '../logging/logger.service';
7	import { EventTypes } from '../public-events/event-types';
8	import { PublicEventsService } from '../public-events/public-events.service';
9	import { StoragePersistenceService } from '../storage/storage-persistence.service';
10	import { IFrameService } from './existing-iframe.service';
11
12	const IFRAME_FOR_CHECK_SESSION_IDENTIFIER = 'myiFrameForCheckSession';	1✔
13
14	// http://openid.net/specs/openid-connect-session-1_0-ID4.html
15
16	@Injectable({ providedIn: 'root' })
17	export class CheckSessionService implements OnDestroy {	1✔
18	private checkSessionReceived = false;	23✔
19
20	private scheduledHeartBeatRunning: any;
21
22	private lastIFrameRefresh = 0;	23✔
23
24	private outstandingMessages = 0;	23✔
25
26	private readonly heartBeatInterval = 3000;	23✔
27
28	private readonly iframeRefreshInterval = 60000;	23✔
29
30	private readonly checkSessionChangedInternal$ = new BehaviorSubject<boolean>(	23✔
31	false
32	);
33
34	private iframeMessageEventListener: any;
35
36	get checkSessionChanged$(): Observable<boolean> {
37	return this.checkSessionChangedInternal$.asObservable();	107✔
38	}
39
40	constructor(
41	private readonly storagePersistenceService: StoragePersistenceService,	23✔
42	private readonly loggerService: LoggerService,	23✔
43	private readonly iFrameService: IFrameService,	23✔
44	private readonly eventService: PublicEventsService,	23✔
45	private readonly zone: NgZone,	23✔
46	@Inject(DOCUMENT) private readonly document: Document	23✔
47	) {}
48
49	ngOnDestroy(): void {
50	this.stop();	×
NEW 51	const windowAsDefaultView = this.document.defaultView;	×
52
NEW 53	if (windowAsDefaultView) {	×
NEW 54	windowAsDefaultView.removeEventListener(	×
55	'message',
56	this.iframeMessageEventListener,
57	false
58	);
59	}
60	}
61
62	isCheckSessionConfigured(configuration: OpenIdConfiguration): boolean {
63	const { startCheckSession } = configuration;	2✔
64
65	return Boolean(startCheckSession);	2✔
66	}
67
68	start(configuration: OpenIdConfiguration): void {
69	if (!!this.scheduledHeartBeatRunning) {	2✔
70	return;	1✔
71	}
72
73	const { clientId } = configuration;	1✔
74
75	this.pollServerSession(clientId, configuration);	1✔
76	}
77
78	stop(): void {
79	if (!this.scheduledHeartBeatRunning) {	2✔
80	return;	1✔
81	}
82
83	this.clearScheduledHeartBeat();	1✔
84	this.checkSessionReceived = false;	1✔
85	}
86
87	serverStateChanged(configuration: OpenIdConfiguration): boolean {
88	const { startCheckSession } = configuration;	3✔
89
90	return Boolean(startCheckSession) && this.checkSessionReceived;	3✔
91	}
92
93	getExistingIframe(): HTMLIFrameElement \| null {
94	return this.iFrameService.getExistingIFrame(	4✔
95	IFRAME_FOR_CHECK_SESSION_IDENTIFIER
96	);
97	}
98
99	private init(configuration: OpenIdConfiguration): Observable<any> {
100	if (this.lastIFrameRefresh + this.iframeRefreshInterval > Date.now()) {	3✔
101	return of(undefined);	1✔
102	}
103
104	const authWellKnownEndPoints = this.storagePersistenceService.read(	2✔
105	'authWellKnownEndPoints',
106	configuration
107	);
108
109	if (!authWellKnownEndPoints) {	2✔
110	this.loggerService.logWarning(	1✔
111	configuration,
112	'CheckSession - init check session: authWellKnownEndpoints is undefined. Returning.'
113	);
114
115	return of();	1✔
116	}
117
118	const existingIframe = this.getOrCreateIframe(configuration);	1✔
119
120	// https://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html#Events-EventTarget-addEventListener
121	// If multiple identical EventListeners are registered on the same EventTarget with the same parameters the duplicate instances are discarded. They do not cause the EventListener to be called twice and since they are discarded they do not need to be removed with the removeEventListener method.
122	// this is done even if iframe exists for HMR to work, since iframe exists on service init
123	this.bindMessageEventToIframe(configuration);	1✔
124	const checkSessionIframe = authWellKnownEndPoints.checkSessionIframe;	1✔
125	const contentWindow = existingIframe.contentWindow;	1✔
126
127	if (!checkSessionIframe) {	1✔
128	this.loggerService.logWarning(	1✔
129	configuration,
130	'CheckSession - init check session: checkSessionIframe is not configured to run'
131	);
132	}
133
134	if (!contentWindow) {	1!
NEW 135	this.loggerService.logWarning(	×
136	configuration,
137	'CheckSession - init check session: IFrame contentWindow does not exist'
138	);
139	} else {
140	contentWindow.location.replace(checkSessionIframe);	1✔
141	}
142
143	return new Observable((observer) => {	1✔
144	existingIframe.onload = (): void => {	×
145	this.lastIFrameRefresh = Date.now();	×
146	observer.next();	×
147	observer.complete();	×
148	};
149	});
150	}
151
152	private pollServerSession(
153	clientId: string \| undefined,
154	configuration: OpenIdConfiguration
155	): void {
156	this.outstandingMessages = 0;	5✔
157
158	const pollServerSessionRecur = (): void => {	5✔
159	this.init(configuration)	5✔
160	.pipe(take(1))
161	.subscribe(() => {
162	const existingIframe = this.getExistingIframe();	5✔
163
164	if (existingIframe && clientId) {	5✔
165	this.loggerService.logDebug(	3✔
166	configuration,
167	`CheckSession - clientId : '${clientId}' - existingIframe: '${existingIframe}'`
168	);
169	const sessionState = this.storagePersistenceService.read(	3✔
170	'session_state',
171	configuration
172	);
173	const authWellKnownEndPoints = this.storagePersistenceService.read(	3✔
174	'authWellKnownEndPoints',
175	configuration
176	);
177	const contentWindow = existingIframe.contentWindow;	3✔
178
179	if (	3✔
180	sessionState &&	6✔
181	authWellKnownEndPoints?.checkSessionIframe &&
182	contentWindow
183	) {
184	const iframeOrigin = new URL(	1✔
185	authWellKnownEndPoints.checkSessionIframe
186	)?.origin;
187
188	this.outstandingMessages++;	1✔
189	contentWindow.postMessage(	1✔
190	clientId + ' ' + sessionState,
191	iframeOrigin
192	);
193	} else {
194	this.loggerService.logDebug(	2✔
195	configuration,
196	`CheckSession - session_state is '${sessionState}' - AuthWellKnownEndPoints is '${JSON.stringify(
197	authWellKnownEndPoints,
198	null,
199	2
200	)}'`
201	);
202	this.checkSessionChangedInternal$.next(true);	2✔
203	}
204	} else {
205	this.loggerService.logWarning(	2✔
206	configuration,
207	`CheckSession - OidcSecurityCheckSession pollServerSession checkSession IFrame does not exist:
208	clientId : '${clientId}' - existingIframe: '${existingIframe}'`
209	);
210	}
211
212	// after sending three messages with no response, fail.
213	if (this.outstandingMessages > 3) {	5!
214	this.loggerService.logError(	×
215	configuration,
216	`CheckSession - OidcSecurityCheckSession not receiving check session response messages.
217	Outstanding messages: '${this.outstandingMessages}'. Server unreachable?`
218	);
219	}
220
221	this.zone.runOutsideAngular(() => {	5✔
222	this.scheduledHeartBeatRunning = setTimeout(	5✔
223	() => this.zone.run(pollServerSessionRecur),	×
224	this.heartBeatInterval
225	);
226	});
227	});
228	};
229
230	pollServerSessionRecur();	5✔
231	}
232
233	private clearScheduledHeartBeat(): void {
234	clearTimeout(this.scheduledHeartBeatRunning);	1✔
235	this.scheduledHeartBeatRunning = null;	1✔
236	}
237
238	private messageHandler(configuration: OpenIdConfiguration, e: any): void {
239	const existingIFrame = this.getExistingIframe();	×
240	const authWellKnownEndPoints = this.storagePersistenceService.read(	×
241	'authWellKnownEndPoints',
242	configuration
243	);
244	const startsWith = !!authWellKnownEndPoints?.checkSessionIframe?.startsWith(	×
245	e.origin
246	);
247
248	this.outstandingMessages = 0;	×
249
250	if (	×
251	existingIFrame &&	×
252	startsWith &&
253	e.source === existingIFrame.contentWindow
254	) {
255	if (e.data === 'error') {	×
256	this.loggerService.logWarning(	×
257	configuration,
258	'CheckSession - error from check session messageHandler'
259	);
260	} else if (e.data === 'changed') {	×
261	this.loggerService.logDebug(	×
262	configuration,
263	`CheckSession - ${e} from check session messageHandler`
264	);
265	this.checkSessionReceived = true;	×
266	this.eventService.fireEvent(EventTypes.CheckSessionReceived, e.data);	×
267	this.checkSessionChangedInternal$.next(true);	×
268	} else {
269	this.eventService.fireEvent(EventTypes.CheckSessionReceived, e.data);	×
270	this.loggerService.logDebug(	×
271	configuration,
272	`CheckSession - ${e.data} from check session messageHandler`
273	);
274	}
275	}
276	}
277
278	private bindMessageEventToIframe(configuration: OpenIdConfiguration): void {
279	this.iframeMessageEventListener = this.messageHandler.bind(	1✔
280	this,
281	configuration
282	);
283
284	const defaultView = this.document.defaultView;	1✔
285
286	if (defaultView) {	1✔
287	defaultView.addEventListener(	1✔
288	'message',
289	this.iframeMessageEventListener,
290	false
291	);
292	}
293	}
294
295	private getOrCreateIframe(
296	configuration: OpenIdConfiguration
297	): HTMLIFrameElement {
298	return (	4✔
299	this.getExistingIframe() \|\|	7✔
300	this.iFrameService.addIFrameToWindowBody(
301	IFRAME_FOR_CHECK_SESSION_IDENTIFIER,
302	configuration
303	)
304	);
305	}
306	}

damienbod / angular-auth-oidc-client / 7775532556

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous