angular-auth-oidc-client
Version:
Angular Lib for OpenID Connect & OAuth2
118 lines • 23.2 kB
JavaScript
import { HttpHeaders } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { of, throwError } from 'rxjs';
import { catchError, retry, switchMap, tap } from 'rxjs/operators';
import * as i0 from "@angular/core";
import * as i1 from "../api/data.service";
import * as i2 from "../storage/storage-persistence.service";
import * as i3 from "../logging/logger.service";
import * as i4 from "../utils/url/url.service";
import * as i5 from "../iframe/check-session.service";
import * as i6 from "../flows/reset-auth-data.service";
import * as i7 from "../utils/redirect/redirect.service";
export class LogoffRevocationService {
constructor(dataService, storagePersistenceService, loggerService, urlService, checkSessionService, resetAuthDataService, redirectService) {
this.dataService = dataService;
this.storagePersistenceService = storagePersistenceService;
this.loggerService = loggerService;
this.urlService = urlService;
this.checkSessionService = checkSessionService;
this.resetAuthDataService = resetAuthDataService;
this.redirectService = redirectService;
}
// Logs out on the server and the local client.
// If the server state has changed, check session, then only a local logout.
logoff(config, allConfigs, authOptions) {
const { urlHandler, customParams } = authOptions || {};
this.loggerService.logDebug(config, 'logoff, remove auth ');
const endSessionUrl = this.getEndSessionUrl(config, customParams);
this.resetAuthDataService.resetAuthorizationData(config, allConfigs);
if (!endSessionUrl) {
this.loggerService.logDebug(config, 'only local login cleaned up, no end_session_endpoint');
return;
}
if (this.checkSessionService.serverStateChanged(config)) {
this.loggerService.logDebug(config, 'only local login cleaned up, server session has changed');
}
else if (urlHandler) {
urlHandler(endSessionUrl);
}
else {
this.redirectService.redirectTo(endSessionUrl);
}
}
logoffLocal(config, allConfigs) {
this.resetAuthDataService.resetAuthorizationData(config, allConfigs);
this.checkSessionService.stop();
}
logoffLocalMultiple(allConfigs) {
allConfigs.forEach((configuration) => this.logoffLocal(configuration, allConfigs));
}
// The refresh token and and the access token are revoked on the server. If the refresh token does not exist
// only the access token is revoked. Then the logout run.
logoffAndRevokeTokens(config, allConfigs, authOptions) {
const { revocationEndpoint } = this.storagePersistenceService.read('authWellKnownEndPoints', config) || {};
if (!revocationEndpoint) {
this.loggerService.logDebug(config, 'revocation endpoint not supported');
this.logoff(config, allConfigs, authOptions);
return of(null);
}
if (this.storagePersistenceService.getRefreshToken(config)) {
return this.revokeRefreshToken(config).pipe(switchMap((_) => this.revokeAccessToken(config)), catchError((error) => {
const errorMessage = `revoke token failed`;
this.loggerService.logError(config, errorMessage, error);
return throwError(() => new Error(errorMessage));
}), tap(() => this.logoff(config, allConfigs, authOptions)));
}
else {
return this.revokeAccessToken(config).pipe(catchError((error) => {
const errorMessage = `revoke accessToken failed`;
this.loggerService.logError(config, errorMessage, error);
return throwError(() => new Error(errorMessage));
}), tap(() => this.logoff(config, allConfigs, authOptions)));
}
}
// https://tools.ietf.org/html/rfc7009
// revokes an access token on the STS. If no token is provided, then the token from
// the storage is revoked. You can pass any token to revoke. This makes it possible to
// manage your own tokens. The is a public API.
revokeAccessToken(configuration, accessToken) {
const accessTok = accessToken || this.storagePersistenceService.getAccessToken(configuration);
const body = this.urlService.createRevocationEndpointBodyAccessToken(accessTok, configuration);
return this.sendRevokeRequest(configuration, body);
}
// https://tools.ietf.org/html/rfc7009
// revokes an refresh token on the STS. This is only required in the code flow with refresh tokens.
// If no token is provided, then the token from the storage is revoked. You can pass any token to revoke.
// This makes it possible to manage your own tokens.
revokeRefreshToken(configuration, refreshToken) {
const refreshTok = refreshToken || this.storagePersistenceService.getRefreshToken(configuration);
const body = this.urlService.createRevocationEndpointBodyRefreshToken(refreshTok, configuration);
return this.sendRevokeRequest(configuration, body);
}
getEndSessionUrl(configuration, customParams) {
const idToken = this.storagePersistenceService.getIdToken(configuration);
const { customParamsEndSessionRequest } = configuration;
const mergedParams = { ...customParamsEndSessionRequest, ...customParams };
return this.urlService.createEndSessionUrl(idToken, configuration, mergedParams);
}
sendRevokeRequest(configuration, body) {
const url = this.urlService.getRevocationEndpointUrl(configuration);
let headers = new HttpHeaders();
headers = headers.set('Content-Type', 'application/x-www-form-urlencoded');
return this.dataService.post(url, body, configuration, headers).pipe(retry(2), switchMap((response) => {
this.loggerService.logDebug(configuration, 'revocation endpoint post response: ', response);
return of(response);
}), catchError((error) => {
const errorMessage = `Revocation request failed`;
this.loggerService.logError(configuration, errorMessage, error);
return throwError(() => new Error(errorMessage));
}));
}
}
LogoffRevocationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: LogoffRevocationService, deps: [{ token: i1.DataService }, { token: i2.StoragePersistenceService }, { token: i3.LoggerService }, { token: i4.UrlService }, { token: i5.CheckSessionService }, { token: i6.ResetAuthDataService }, { token: i7.RedirectService }], target: i0.ɵɵFactoryTarget.Injectable });
LogoffRevocationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: LogoffRevocationService });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: LogoffRevocationService, decorators: [{
type: Injectable
}], ctorParameters: function () { return [{ type: i1.DataService }, { type: i2.StoragePersistenceService }, { type: i3.LoggerService }, { type: i4.UrlService }, { type: i5.CheckSessionService }, { type: i6.ResetAuthDataService }, { type: i7.RedirectService }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logoff-revocation.service.js","sourceRoot":"","sources":["../../../../../projects/angular-auth-oidc-client/src/lib/logoff-revoke/logoff-revocation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpHeaders } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { Observable, of, throwError } from 'rxjs';\r\nimport { catchError, retry, switchMap, tap } from 'rxjs/operators';\r\nimport { DataService } from '../api/data.service';\r\nimport { AuthOptions } from '../auth-options';\r\nimport { OpenIdConfiguration } from '../config/openid-configuration';\r\nimport { ResetAuthDataService } from '../flows/reset-auth-data.service';\r\nimport { CheckSessionService } from '../iframe/check-session.service';\r\nimport { LoggerService } from '../logging/logger.service';\r\nimport { StoragePersistenceService } from '../storage/storage-persistence.service';\r\nimport { RedirectService } from '../utils/redirect/redirect.service';\r\nimport { UrlService } from '../utils/url/url.service';\r\n\r\n@Injectable()\r\nexport class LogoffRevocationService {\r\n  constructor(\r\n    private readonly dataService: DataService,\r\n    private readonly storagePersistenceService: StoragePersistenceService,\r\n    private readonly loggerService: LoggerService,\r\n    private readonly urlService: UrlService,\r\n    private readonly checkSessionService: CheckSessionService,\r\n    private readonly resetAuthDataService: ResetAuthDataService,\r\n    private readonly redirectService: RedirectService\r\n  ) {}\r\n\r\n  // Logs out on the server and the local client.\r\n  // If the server state has changed, check session, then only a local logout.\r\n  logoff(config: OpenIdConfiguration, allConfigs: OpenIdConfiguration[], authOptions?: AuthOptions): void {\r\n    const { urlHandler, customParams } = authOptions || {};\r\n\r\n    this.loggerService.logDebug(config, 'logoff, remove auth ');\r\n\r\n    const endSessionUrl = this.getEndSessionUrl(config, customParams);\r\n\r\n    this.resetAuthDataService.resetAuthorizationData(config, allConfigs);\r\n\r\n    if (!endSessionUrl) {\r\n      this.loggerService.logDebug(config, 'only local login cleaned up, no end_session_endpoint');\r\n\r\n      return;\r\n    }\r\n\r\n    if (this.checkSessionService.serverStateChanged(config)) {\r\n      this.loggerService.logDebug(config, 'only local login cleaned up, server session has changed');\r\n    } else if (urlHandler) {\r\n      urlHandler(endSessionUrl);\r\n    } else {\r\n      this.redirectService.redirectTo(endSessionUrl);\r\n    }\r\n  }\r\n\r\n  logoffLocal(config: OpenIdConfiguration, allConfigs: OpenIdConfiguration[]): void {\r\n    this.resetAuthDataService.resetAuthorizationData(config, allConfigs);\r\n    this.checkSessionService.stop();\r\n  }\r\n\r\n  logoffLocalMultiple(allConfigs: OpenIdConfiguration[]): void {\r\n    allConfigs.forEach((configuration) => this.logoffLocal(configuration, allConfigs));\r\n  }\r\n\r\n  // The refresh token and and the access token are revoked on the server. If the refresh token does not exist\r\n  // only the access token is revoked. Then the logout run.\r\n  logoffAndRevokeTokens(config: OpenIdConfiguration, allConfigs: OpenIdConfiguration[], authOptions?: AuthOptions): Observable<any> {\r\n    const { revocationEndpoint } = this.storagePersistenceService.read('authWellKnownEndPoints', config) || {};\r\n\r\n    if (!revocationEndpoint) {\r\n      this.loggerService.logDebug(config, 'revocation endpoint not supported');\r\n      this.logoff(config, allConfigs, authOptions);\r\n\r\n      return of(null);\r\n    }\r\n\r\n    if (this.storagePersistenceService.getRefreshToken(config)) {\r\n      return this.revokeRefreshToken(config).pipe(\r\n        switchMap((_) => this.revokeAccessToken(config)),\r\n        catchError((error) => {\r\n          const errorMessage = `revoke token failed`;\r\n\r\n          this.loggerService.logError(config, errorMessage, error);\r\n\r\n          return throwError(() => new Error(errorMessage));\r\n        }),\r\n        tap(() => this.logoff(config, allConfigs, authOptions))\r\n      );\r\n    } else {\r\n      return this.revokeAccessToken(config).pipe(\r\n        catchError((error) => {\r\n          const errorMessage = `revoke accessToken failed`;\r\n\r\n          this.loggerService.logError(config, errorMessage, error);\r\n\r\n          return throwError(() => new Error(errorMessage));\r\n        }),\r\n        tap(() => this.logoff(config, allConfigs, authOptions))\r\n      );\r\n    }\r\n  }\r\n\r\n  // https://tools.ietf.org/html/rfc7009\r\n  // revokes an access token on the STS. If no token is provided, then the token from\r\n  // the storage is revoked. You can pass any token to revoke. This makes it possible to\r\n  // manage your own tokens. The is a public API.\r\n  revokeAccessToken(configuration: OpenIdConfiguration, accessToken?: any): Observable<any> {\r\n    const accessTok = accessToken || this.storagePersistenceService.getAccessToken(configuration);\r\n    const body = this.urlService.createRevocationEndpointBodyAccessToken(accessTok, configuration);\r\n\r\n    return this.sendRevokeRequest(configuration, body);\r\n  }\r\n\r\n  // https://tools.ietf.org/html/rfc7009\r\n  // revokes an refresh token on the STS. This is only required in the code flow with refresh tokens.\r\n  // If no token is provided, then the token from the storage is revoked. You can pass any token to revoke.\r\n  // This makes it possible to manage your own tokens.\r\n  revokeRefreshToken(configuration: OpenIdConfiguration, refreshToken?: any): Observable<any> {\r\n    const refreshTok = refreshToken || this.storagePersistenceService.getRefreshToken(configuration);\r\n    const body = this.urlService.createRevocationEndpointBodyRefreshToken(refreshTok, configuration);\r\n\r\n    return this.sendRevokeRequest(configuration, body);\r\n  }\r\n\r\n  getEndSessionUrl(configuration: OpenIdConfiguration, customParams?: { [p: string]: string | number | boolean }): string | null {\r\n    const idToken = this.storagePersistenceService.getIdToken(configuration);\r\n    const { customParamsEndSessionRequest } = configuration;\r\n\r\n    const mergedParams = { ...customParamsEndSessionRequest, ...customParams };\r\n\r\n    return this.urlService.createEndSessionUrl(idToken, configuration, mergedParams);\r\n  }\r\n\r\n  private sendRevokeRequest(configuration: OpenIdConfiguration, body: string): Observable<any> {\r\n    const url = this.urlService.getRevocationEndpointUrl(configuration);\r\n\r\n    let headers: HttpHeaders = new HttpHeaders();\r\n\r\n    headers = headers.set('Content-Type', 'application/x-www-form-urlencoded');\r\n\r\n    return this.dataService.post(url, body, configuration, headers).pipe(\r\n      retry(2),\r\n      switchMap((response: any) => {\r\n        this.loggerService.logDebug(configuration, 'revocation endpoint post response: ', response);\r\n\r\n        return of(response);\r\n      }),\r\n      catchError((error) => {\r\n        const errorMessage = `Revocation request failed`;\r\n\r\n        this.loggerService.logError(configuration, errorMessage, error);\r\n\r\n        return throwError(() => new Error(errorMessage));\r\n      })\r\n    );\r\n  }\r\n}\r\n"]}