From 4855c3512fa762f5134f0c3fb7861932c6910708 Mon Sep 17 00:00:00 2001 From: Arsalan Salari Date: Tue, 7 Sep 2021 11:16:09 +0430 Subject: [PATCH 01/13] Add base class for auth & end session requests --- src/authorization_management_request.ts | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 src/authorization_management_request.ts diff --git a/src/authorization_management_request.ts b/src/authorization_management_request.ts new file mode 100644 index 0000000..1066fd9 --- /dev/null +++ b/src/authorization_management_request.ts @@ -0,0 +1,22 @@ +/* + * Copyright 2017 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the + * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. See the License for the specific language governing permissions and + * limitations under the License. + */ + +export abstract class AuthorizationManagementRequest { + public abstract state: string; + + /* + * Serializes the request object to a JavaScript object + */ + public abstract toJson(): Promise; +} From 8e5a5b2996e4812d18b75d03829194ddc361e69d Mon Sep 17 00:00:00 2001 From: Arsalan Salari Date: Tue, 7 Sep 2021 11:18:32 +0430 Subject: [PATCH 02/13] Add end session request and authorization request --- src/authorization_request.ts | 4 +- src/endsession_request.ts | 76 ++++++++++++++++++++++++++++++++++++ 2 files changed, 79 insertions(+), 1 deletion(-) create mode 100644 src/endsession_request.ts diff --git a/src/authorization_request.ts b/src/authorization_request.ts index 775edf0..e3b83cb 100644 --- a/src/authorization_request.ts +++ b/src/authorization_request.ts @@ -12,6 +12,7 @@ * limitations under the License. */ +import {AuthorizationManagementRequest} from './authorization_management_request' import {Crypto, DefaultCrypto} from './crypto_utils'; import {log} from './logger'; import {StringMap} from './types'; @@ -42,7 +43,7 @@ const newState = function(crypto: Crypto): string { * For more information look at * https://tools.ietf.org/html/rfc6749#section-4.1.1 */ -export class AuthorizationRequest { +export class AuthorizationRequest extends AuthorizationManagementRequest { static RESPONSE_TYPE_TOKEN = 'token'; static RESPONSE_TYPE_CODE = 'code'; @@ -66,6 +67,7 @@ export class AuthorizationRequest { request: AuthorizationRequestJson, private crypto: Crypto = new DefaultCrypto(), private usePkce: boolean = true) { + super(); this.clientId = request.client_id; this.redirectUri = request.redirect_uri; this.scope = request.scope; diff --git a/src/endsession_request.ts b/src/endsession_request.ts new file mode 100644 index 0000000..17fc2d7 --- /dev/null +++ b/src/endsession_request.ts @@ -0,0 +1,76 @@ +/* + * Copyright 2017 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the + * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. See the License for the specific language governing permissions and + * limitations under the License. + */ + +import {AuthorizationManagementRequest} from './authorization_management_request' +import {Crypto, DefaultCrypto} from './crypto_utils'; +import {StringMap} from './types'; + +/** + * Represents an EndSessionRequest as JSON. + */ +export interface EndSessionRequestJson { + id_token_hint: string; + post_logout_redirect_uri: string; + state?: string; + extras?: StringMap; +} + +/** + * Generates a cryptographically random new state. Useful for CSRF protection. + */ +const SIZE = 10; // 10 bytes +const newState = function(crypto: Crypto): string { + return crypto.generateRandom(SIZE); +}; + +/** + * Represents the EndSessionRequest. + * For more information look at + * http://openid.net/specs/openid-connect-session-1_0.html + */ +export class EndSessionRequest extends AuthorizationManagementRequest { + // NOTE: + // Both post_logout_redirect_uri and state are actually optional. + // However AppAuth is more opionionated, and requires you to use both. + + idTokenHint: string; + postLogoutRedirectUri: string; + state: string; + extras?: StringMap; + + /** + * Constructs a new EndSessionRequest. + * Use a `undefined` value for the `state` parameter, to generate a random + * state for CSRF protection. + */ + constructor(request: EndSessionRequestJson, private crypto: Crypto = new DefaultCrypto()) { + super(); + this.idTokenHint = request.id_token_hint; + this.postLogoutRedirectUri = request.post_logout_redirect_uri; + this.state = request.state || newState(crypto); + this.extras = request.extras; + } + + /** + * Serializes the EndSessionRequest to a JavaScript Object. + */ + toJson(): Promise { + return Promise.resolve({ + id_token_hint: this.idTokenHint, + post_logout_redirect_uri: this.postLogoutRedirectUri, + state: this.state, + extras: this.extras + }); + } +} \ No newline at end of file From 59e7d52d038e87d632350d7ebafedda1fe5da166 Mon Sep 17 00:00:00 2001 From: Arsalan Salari Date: Tue, 7 Sep 2021 11:23:05 +0430 Subject: [PATCH 03/13] Fix naming --- src/{endsession_request.ts => end_session_request.ts} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/{endsession_request.ts => end_session_request.ts} (100%) diff --git a/src/endsession_request.ts b/src/end_session_request.ts similarity index 100% rename from src/endsession_request.ts rename to src/end_session_request.ts From d785c682c1df0e8111e46165a3a6c06d3dec5614 Mon Sep 17 00:00:00 2001 From: Arsalan Salari Date: Tue, 7 Sep 2021 11:34:27 +0430 Subject: [PATCH 04/13] Add end_session_response file. first refactor all redirect based responses to use a generic base class then create EndSession responses and AuthorizationResponse to use this class --- src/authorization_management_response.ts | 56 ++++++++++++++++++++++++ src/authorization_response.ts | 45 +++---------------- src/end_session_response.ts | 40 +++++++++++++++++ 3 files changed, 101 insertions(+), 40 deletions(-) create mode 100644 src/authorization_management_response.ts create mode 100644 src/end_session_response.ts diff --git a/src/authorization_management_response.ts b/src/authorization_management_response.ts new file mode 100644 index 0000000..94c7b9c --- /dev/null +++ b/src/authorization_management_response.ts @@ -0,0 +1,56 @@ +/* + * Copyright 2017 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the + * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Represents the AuthorizationError as a JSON object. + */ +export interface AuthorizationErrorJson { + error: string; + error_description?: string; + error_uri?: string; + state?: string; +} + +export abstract class AuthorizationManagementResponse { + abstract state: string; + public abstract toJson(): object; +} + +/** + * Represents the Authorization error response. + * For more information look at: + * https://tools.ietf.org/html/rfc6749#section-4.1.2.1 + */ +export class AuthorizationError { + error: string; + errorDescription?: string; + errorUri?: string; + state?: string; + + constructor(error: AuthorizationErrorJson) { + this.error = error.error; + this.errorDescription = error.error_description; + this.errorUri = error.error_uri; + this.state = error.state; + } + + toJson(): AuthorizationErrorJson { + return { + error: this.error, + error_description: this.errorDescription, + error_uri: this.errorUri, + state: this.state, + }; + } +} diff --git a/src/authorization_response.ts b/src/authorization_response.ts index 733061e..394d0ac 100644 --- a/src/authorization_response.ts +++ b/src/authorization_response.ts @@ -12,6 +12,8 @@ * limitations under the License. */ +import {AuthorizationManagementResponse} from './authorization_management_response' + /** * Represents the AuthorizationResponse as a JSON object. */ @@ -20,26 +22,17 @@ export interface AuthorizationResponseJson { state: string; } -/** - * Represents the AuthorizationError as a JSON object. - */ -export interface AuthorizationErrorJson { - error: string; - error_description?: string; - error_uri?: string; - state?: string; -} - /** * Represents the Authorization Response type. * For more information look at * https://tools.ietf.org/html/rfc6749#section-4.1.2 */ -export class AuthorizationResponse { +export class AuthorizationResponse extends AuthorizationManagementResponse{ code: string; state: string; constructor(response: AuthorizationResponseJson) { + super(); this.code = response.code; this.state = response.state; } @@ -47,32 +40,4 @@ export class AuthorizationResponse { toJson(): AuthorizationResponseJson { return {code: this.code, state: this.state}; } -} - -/** - * Represents the Authorization error response. - * For more information look at: - * https://tools.ietf.org/html/rfc6749#section-4.1.2.1 - */ -export class AuthorizationError { - error: string; - errorDescription?: string; - errorUri?: string; - state?: string; - - constructor(error: AuthorizationErrorJson) { - this.error = error.error; - this.errorDescription = error.error_description; - this.errorUri = error.error_uri; - this.state = error.state; - } - - toJson(): AuthorizationErrorJson { - return { - error: this.error, - error_description: this.errorDescription, - error_uri: this.errorUri, - state: this.state - }; - } -} +} \ No newline at end of file diff --git a/src/end_session_response.ts b/src/end_session_response.ts new file mode 100644 index 0000000..de2fa68 --- /dev/null +++ b/src/end_session_response.ts @@ -0,0 +1,40 @@ +/* + * Copyright 2017 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the + * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. See the License for the specific language governing permissions and + * limitations under the License. + */ + +import {AuthorizationManagementResponse} from './authorization_management_response' + +/** + * Represents the EndSessionResponse as a JSON object. + */ + export interface EndSessionResponseJson { + state: string; +} + +/** + * Represents the EndSession Response type. + * For more information look at + * http://openid.net/specs/openid-connect-session-1_0.html + */ +export class EndSessionResponse extends AuthorizationManagementResponse { + state: string; + + constructor(response: EndSessionResponseJson) { + super(); + this.state = response.state; + } + + toJson(): EndSessionResponseJson { + return {state: this.state}; + } +} \ No newline at end of file From a787bccb88a952a6d1cd82d0fb38d6ea4a1ef987 Mon Sep 17 00:00:00 2001 From: Arsalan Salari Date: Thu, 9 Sep 2021 09:19:09 +0430 Subject: [PATCH 05/13] Add endSession redirect_based_handler --- src/authorization_management_request.ts | 4 + src/authorization_request.ts | 46 +++++-- src/authorization_request_handler.ts | 45 ++----- src/end_session_redirect_based_handler.ts | 145 ++++++++++++++++++++++ src/end_session_request.ts | 28 +++++ src/redirect_based_handler.ts | 3 +- 6 files changed, 229 insertions(+), 42 deletions(-) create mode 100644 src/end_session_redirect_based_handler.ts diff --git a/src/authorization_management_request.ts b/src/authorization_management_request.ts index 1066fd9..b826157 100644 --- a/src/authorization_management_request.ts +++ b/src/authorization_management_request.ts @@ -12,6 +12,8 @@ * limitations under the License. */ +import {StringMap} from "./types"; + export abstract class AuthorizationManagementRequest { public abstract state: string; @@ -19,4 +21,6 @@ export abstract class AuthorizationManagementRequest { * Serializes the request object to a JavaScript object */ public abstract toJson(): Promise; + + public abstract toRequestMap(): StringMap; } diff --git a/src/authorization_request.ts b/src/authorization_request.ts index e3b83cb..eb25bd2 100644 --- a/src/authorization_request.ts +++ b/src/authorization_request.ts @@ -12,11 +12,17 @@ * limitations under the License. */ -import {AuthorizationManagementRequest} from './authorization_management_request' +import {AuthorizationManagementRequest} from './authorization_management_request'; import {Crypto, DefaultCrypto} from './crypto_utils'; import {log} from './logger'; import {StringMap} from './types'; + + +// TODO(rahulrav@): add more built in parameters. +/* built in parameters. */ +export const BUILT_IN_PARAMETERS = ['redirect_uri', 'client_id', 'response_type', 'state', 'scope']; + /** * Represents an AuthorizationRequest as JSON. */ @@ -33,7 +39,7 @@ export interface AuthorizationRequestJson { /** * Generates a cryptographically random new state. Useful for CSRF protection. */ -const SIZE = 10; // 10 bytes +const SIZE = 10; // 10 bytes const newState = function(crypto: Crypto): string { return crypto.generateRandom(SIZE); }; @@ -64,9 +70,9 @@ export class AuthorizationRequest extends AuthorizationManagementRequest { * state for CSRF protection. */ constructor( - request: AuthorizationRequestJson, - private crypto: Crypto = new DefaultCrypto(), - private usePkce: boolean = true) { + request: AuthorizationRequestJson, + private crypto: Crypto = new DefaultCrypto(), + private usePkce: boolean = true) { super(); this.clientId = request.client_id; this.redirectUri = request.redirect_uri; @@ -85,9 +91,9 @@ export class AuthorizationRequest extends AuthorizationManagementRequest { const codeVerifier = this.crypto.generateRandom(128); const challenge: Promise = this.crypto.deriveChallenge(codeVerifier).catch(error => { - log('Unable to generate PKCE challenge. Not using PKCE', error); - return undefined; - }); + log('Unable to generate PKCE challenge. Not using PKCE', error); + return undefined; + }); return challenge.then(result => { if (result) { // keep track of the code used. @@ -119,4 +125,28 @@ export class AuthorizationRequest extends AuthorizationManagementRequest { }; }); } + toRequestMap(): StringMap { + // build the query string + // coerce to any type for convenience + let requestMap: StringMap = { + redirect_uri: this.redirectUri, + client_id: this.clientId, + response_type: this.responseType, + state: this.state, + scope: this.scope, + }; + + // copy over extras + if (this.extras) { + for (let extra in this.extras) { + if (this.extras.hasOwnProperty(extra)) { + // check before inserting to requestMap + if (BUILT_IN_PARAMETERS.indexOf(extra) < 0) { + requestMap[extra] = this.extras[extra]; + } + } + } + } + return requestMap + } } diff --git a/src/authorization_request_handler.ts b/src/authorization_request_handler.ts index 1739718..a299ba1 100644 --- a/src/authorization_request_handler.ts +++ b/src/authorization_request_handler.ts @@ -12,8 +12,9 @@ * limitations under the License. */ -import {AuthorizationRequest} from './authorization_request'; -import {AuthorizationError, AuthorizationResponse} from './authorization_response'; +import {AuthorizationManagementRequest} from './authorization_management_request'; +import {AuthorizationManagementResponse} from './authorization_management_response'; +import {AuthorizationError} from './authorization_management_response'; import {AuthorizationServiceConfiguration} from './authorization_service_configuration'; import {Crypto} from './crypto_utils'; import {log} from './logger'; @@ -26,16 +27,16 @@ import {StringMap} from './types'; * and an AuthorizationResponse as arguments. */ export type AuthorizationListener = - (request: AuthorizationRequest, - response: AuthorizationResponse|null, + (request: AuthorizationManagementRequest, + response: AuthorizationManagementResponse|null, error: AuthorizationError|null) => void; /** * Represents a structural type holding both authorization request and response. */ export interface AuthorizationRequestResponse { - request: AuthorizationRequest; - response: AuthorizationResponse|null; + request: AuthorizationManagementRequest; + response: AuthorizationManagementResponse|null; error: AuthorizationError|null; } @@ -54,8 +55,8 @@ export class AuthorizationNotifier { * The authorization complete callback. */ onAuthorizationComplete( - request: AuthorizationRequest, - response: AuthorizationResponse|null, + request: AuthorizationManagementRequest, + response: AuthorizationManagementResponse|null, error: AuthorizationError|null): void { if (this.listener) { // complete authorization request @@ -64,9 +65,6 @@ export class AuthorizationNotifier { } } -// TODO(rahulrav@): add more built in parameters. -/* built in parameters. */ -export const BUILT_IN_PARAMETERS = ['redirect_uri', 'client_id', 'response_type', 'state', 'scope']; /** * Defines the interface which is capable of handling an authorization request @@ -83,29 +81,10 @@ export abstract class AuthorizationRequestHandler { */ protected buildRequestUrl( configuration: AuthorizationServiceConfiguration, - request: AuthorizationRequest) { + request: AuthorizationManagementRequest) { // build the query string // coerce to any type for convenience - let requestMap: StringMap = { - 'redirect_uri': request.redirectUri, - 'client_id': request.clientId, - 'response_type': request.responseType, - 'state': request.state, - 'scope': request.scope - }; - - // copy over extras - if (request.extras) { - for (let extra in request.extras) { - if (request.extras.hasOwnProperty(extra)) { - // check before inserting to requestMap - if (BUILT_IN_PARAMETERS.indexOf(extra) < 0) { - requestMap[extra] = request.extras[extra]; - } - } - } - } - + let requestMap: StringMap = request.toRequestMap() let query = this.utils.stringify(requestMap); let baseUrl = configuration.authorizationEndpoint; let url = `${baseUrl}?${query}`; @@ -146,7 +125,7 @@ export abstract class AuthorizationRequestHandler { */ abstract performAuthorizationRequest( configuration: AuthorizationServiceConfiguration, - request: AuthorizationRequest): void; + request: AuthorizationManagementRequest): void; /** * Checks if an authorization flow can be completed, and completes it. diff --git a/src/end_session_redirect_based_handler.ts b/src/end_session_redirect_based_handler.ts new file mode 100644 index 0000000..06a3087 --- /dev/null +++ b/src/end_session_redirect_based_handler.ts @@ -0,0 +1,145 @@ +/* + * Copyright 2017 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the + * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. See the License for the specific language governing permissions and + * limitations under the License. + */ + +import {AuthorizationServiceConfiguration} from './authorization_service_configuration'; +import {Crypto, DefaultCrypto} from './crypto_utils'; +import {EndSessionRequest} from './end_session_request'; +import {AuthorizationRequestHandler, AuthorizationRequestResponse} from './authorization_request_handler'; +import {EndSessionResponse} from './end_session_response' +import { AuthorizationError } from './authorization_management_response'; +import {log} from './logger'; +import {BasicQueryStringUtils} from './query_string_utils'; +import {LocalStorageBackend, StorageBackend} from './storage'; +import {LocationLike} from './types'; + + +/** key for endsession request. */ +const endSessionRequestKey = + (handle: string) => { + return `${handle}_appauth_endsession_request`; + } + +/** key for authorization service configuration */ +const authorizationServiceConfigurationKey = + (handle: string) => { + return `${handle}_appauth_authorization_service_configuration`; + } + +/** key in local storage which represents the current endsession request. */ +const ENDSESSION_REQUEST_HANDLE_KEY = 'appauth_current_endsession_request'; + +/** + * Represents an EndSessionRequestHandler which uses a standard + * redirect based code flow. + */ +export class EndSessionRedirectRequestHandler extends AuthorizationRequestHandler { + constructor( + // use the provided storage backend + // or initialize local storage with the default storage backend which + // uses window.localStorage + public storageBackend: StorageBackend = new LocalStorageBackend(), + utils = new BasicQueryStringUtils(), + public locationLike: LocationLike = window.location, + crypto: Crypto = new DefaultCrypto()) { + super(utils, crypto); + } + + performAuthorizationRequest( + configuration: AuthorizationServiceConfiguration, + request: EndSessionRequest) { + const handle = this.crypto.generateRandom(10); + // before you make request, persist all request related data in local storage. + let persisted = Promise.all([ + this.storageBackend.setItem(ENDSESSION_REQUEST_HANDLE_KEY, handle), + request.toJson().then( + result => + this.storageBackend.setItem(endSessionRequestKey(handle), JSON.stringify(result))), + this.storageBackend.setItem( + authorizationServiceConfigurationKey(handle), JSON.stringify(configuration.toJson())), + ]); + + persisted.then(() => { + // make the redirect request + let url = this.buildRequestUrl(configuration, request); + log('Making a request to ', request, url); + this.locationLike.assign(url); + }); + } + + /** + * Attempts to introspect the contents of storage backend and completes the + * request. + */ + protected completeAuthorizationRequest(): Promise { + // TODO(rahulrav@): handle endsession errors. + return this.storageBackend.getItem(ENDSESSION_REQUEST_HANDLE_KEY).then(handle => { + if (handle) { + // we have a pending request. + // fetch endsession request, and check state + return this.storageBackend + .getItem(endSessionRequestKey(handle)) + // requires a corresponding instance of result + // TODO(rahulrav@): check for inconsitent state here + .then(result => JSON.parse(result!)) + .then(json => new EndSessionRequest(json)) + .then(request => { + // check redirect_uri and state + let currentUri = `${this.locationLike.origin}${this.locationLike.pathname}`; + let queryParams = this.utils.parse(this.locationLike, true /* use hash */); + let state: string|undefined = queryParams['state']; + let error: string|undefined = queryParams['error']; + log('Potential endsession request ', currentUri, queryParams, state, error); + let shouldNotify = state === request.state; + let endSessionResponse: EndSessionResponse|null = null; + let endSessionError: AuthorizationError|null = null; + if (shouldNotify) { + if (error) { + // get additional optional info. + let errorUri = queryParams['error_uri']; + let errorDescription = queryParams['error_description']; + endSessionError = new AuthorizationError({ + error: error, + error_description: errorDescription, + error_uri: errorUri, + state: state + }); + } else { + endSessionResponse = new EndSessionResponse({state: state}); + } + // cleanup state + return Promise + .all([ + this.storageBackend.removeItem(ENDSESSION_REQUEST_HANDLE_KEY), + this.storageBackend.removeItem(endSessionRequestKey(handle)), + this.storageBackend.removeItem(authorizationServiceConfigurationKey(handle)) + ]) + .then(() => { + log('Delivering endsession response'); + return { + request: request, + response: endSessionResponse, + error: endSessionError + } as AuthorizationRequestResponse; + }); + } else { + log('Mismatched request (state and request_uri) dont match.'); + return Promise.resolve(null); + } + }); + } else { + return null; + } + }); + } +} \ No newline at end of file diff --git a/src/end_session_request.ts b/src/end_session_request.ts index 17fc2d7..dbe444d 100644 --- a/src/end_session_request.ts +++ b/src/end_session_request.ts @@ -34,6 +34,11 @@ const newState = function(crypto: Crypto): string { return crypto.generateRandom(SIZE); }; +// TODO(rahulrav@): add more built in parameters. +/* built in parameters. */ +export const ENDSESSION_BUILT_IN_PARAMETERS = + ['id_token_hint', 'post_logout_redirect_uri', 'state']; + /** * Represents the EndSessionRequest. * For more information look at @@ -73,4 +78,27 @@ export class EndSessionRequest extends AuthorizationManagementRequest { extras: this.extras }); } + + toRequestMap(): StringMap { + // build the query string + // coerce to any type for convenience + let requestMap: StringMap = { + 'id_token_hint': this.idTokenHint, + 'post_logout_redirect_uri': this.postLogoutRedirectUri, + 'state': this.state + }; + + // copy over extras + if (this.extras) { + for (let extra in this.extras) { + if (this.extras.hasOwnProperty(extra)) { + // check before inserting to requestMap + if (ENDSESSION_BUILT_IN_PARAMETERS.indexOf(extra) < 0) { + requestMap[extra] = this.extras[extra]; + } + } + } + } + return requestMap; + } } \ No newline at end of file diff --git a/src/redirect_based_handler.ts b/src/redirect_based_handler.ts index 7a5f7ea..7f08a7e 100644 --- a/src/redirect_based_handler.ts +++ b/src/redirect_based_handler.ts @@ -14,7 +14,8 @@ import {AuthorizationRequest} from './authorization_request'; import {AuthorizationRequestHandler, AuthorizationRequestResponse} from './authorization_request_handler'; -import {AuthorizationError, AuthorizationResponse} from './authorization_response' +import {AuthorizationResponse} from './authorization_response' +import {AuthorizationError} from './authorization_management_response'; import {AuthorizationServiceConfiguration} from './authorization_service_configuration'; import {Crypto, DefaultCrypto} from './crypto_utils'; import {log} from './logger'; From 13a219e6d2a1fafb0a162545cc4df09974f4991b Mon Sep 17 00:00:00 2001 From: Arsalan Salari Date: Thu, 9 Sep 2021 09:55:26 +0430 Subject: [PATCH 06/13] Fix typing and code formatting issues --- src/app/index.ts | 2 +- src/authorization_management_request.ts | 2 +- src/authorization_request.ts | 14 +++++++------- src/authorization_response.ts | 2 +- src/end_session_redirect_based_handler.ts | 4 ++-- src/end_session_request.ts | 2 +- src/end_session_response.ts | 2 +- src/node_app/index.ts | 2 +- src/node_support/node_request_handler.ts | 3 ++- src/redirect_based_handler.ts | 2 +- 10 files changed, 18 insertions(+), 17 deletions(-) diff --git a/src/app/index.ts b/src/app/index.ts index a4a8d41..3060ddb 100644 --- a/src/app/index.ts +++ b/src/app/index.ts @@ -74,7 +74,7 @@ export class App { // set a listener to listen for authorization responses this.notifier.setAuthorizationListener((request, response, error) => { log('Authorization request complete ', request, response, error); - if (response) { + if (response && response instanceof AuthorizationResponse && request instanceof AuthorizationRequest) { this.request = request; this.response = response; this.code = response.code; diff --git a/src/authorization_management_request.ts b/src/authorization_management_request.ts index b826157..ee16825 100644 --- a/src/authorization_management_request.ts +++ b/src/authorization_management_request.ts @@ -12,7 +12,7 @@ * limitations under the License. */ -import {StringMap} from "./types"; +import {StringMap} from './types'; export abstract class AuthorizationManagementRequest { public abstract state: string; diff --git a/src/authorization_request.ts b/src/authorization_request.ts index eb25bd2..bf3f829 100644 --- a/src/authorization_request.ts +++ b/src/authorization_request.ts @@ -39,7 +39,7 @@ export interface AuthorizationRequestJson { /** * Generates a cryptographically random new state. Useful for CSRF protection. */ -const SIZE = 10; // 10 bytes +const SIZE = 10; // 10 bytes const newState = function(crypto: Crypto): string { return crypto.generateRandom(SIZE); }; @@ -70,9 +70,9 @@ export class AuthorizationRequest extends AuthorizationManagementRequest { * state for CSRF protection. */ constructor( - request: AuthorizationRequestJson, - private crypto: Crypto = new DefaultCrypto(), - private usePkce: boolean = true) { + request: AuthorizationRequestJson, + private crypto: Crypto = new DefaultCrypto(), + private usePkce: boolean = true) { super(); this.clientId = request.client_id; this.redirectUri = request.redirect_uri; @@ -91,9 +91,9 @@ export class AuthorizationRequest extends AuthorizationManagementRequest { const codeVerifier = this.crypto.generateRandom(128); const challenge: Promise = this.crypto.deriveChallenge(codeVerifier).catch(error => { - log('Unable to generate PKCE challenge. Not using PKCE', error); - return undefined; - }); + log('Unable to generate PKCE challenge. Not using PKCE', error); + return undefined; + }); return challenge.then(result => { if (result) { // keep track of the code used. diff --git a/src/authorization_response.ts b/src/authorization_response.ts index 394d0ac..d413e8f 100644 --- a/src/authorization_response.ts +++ b/src/authorization_response.ts @@ -27,7 +27,7 @@ export interface AuthorizationResponseJson { * For more information look at * https://tools.ietf.org/html/rfc6749#section-4.1.2 */ -export class AuthorizationResponse extends AuthorizationManagementResponse{ +export class AuthorizationResponse extends AuthorizationManagementResponse { code: string; state: string; diff --git a/src/end_session_redirect_based_handler.ts b/src/end_session_redirect_based_handler.ts index 06a3087..8fbec64 100644 --- a/src/end_session_redirect_based_handler.ts +++ b/src/end_session_redirect_based_handler.ts @@ -12,12 +12,12 @@ * limitations under the License. */ +import {AuthorizationError} from './authorization_management_response'; +import {AuthorizationRequestHandler, AuthorizationRequestResponse} from './authorization_request_handler'; import {AuthorizationServiceConfiguration} from './authorization_service_configuration'; import {Crypto, DefaultCrypto} from './crypto_utils'; import {EndSessionRequest} from './end_session_request'; -import {AuthorizationRequestHandler, AuthorizationRequestResponse} from './authorization_request_handler'; import {EndSessionResponse} from './end_session_response' -import { AuthorizationError } from './authorization_management_response'; import {log} from './logger'; import {BasicQueryStringUtils} from './query_string_utils'; import {LocalStorageBackend, StorageBackend} from './storage'; diff --git a/src/end_session_request.ts b/src/end_session_request.ts index dbe444d..2ad04f3 100644 --- a/src/end_session_request.ts +++ b/src/end_session_request.ts @@ -79,7 +79,7 @@ export class EndSessionRequest extends AuthorizationManagementRequest { }); } - toRequestMap(): StringMap { + toRequestMap(): StringMap { // build the query string // coerce to any type for convenience let requestMap: StringMap = { diff --git a/src/end_session_response.ts b/src/end_session_response.ts index de2fa68..22c7e7b 100644 --- a/src/end_session_response.ts +++ b/src/end_session_response.ts @@ -17,7 +17,7 @@ import {AuthorizationManagementResponse} from './authorization_management_respon /** * Represents the EndSessionResponse as a JSON object. */ - export interface EndSessionResponseJson { +export interface EndSessionResponseJson { state: string; } diff --git a/src/node_app/index.ts b/src/node_app/index.ts index d0f2fe7..368195f 100644 --- a/src/node_app/index.ts +++ b/src/node_app/index.ts @@ -59,7 +59,7 @@ export class App { this.notifier.setAuthorizationListener((request, response, error) => { log('Authorization request complete ', request, response, error); if (response) { - this.makeRefreshTokenRequest(this.configuration!, request, response) + this.makeRefreshTokenRequest(this.configuration!, request as AuthorizationRequest, response as AuthorizationResponse) .then(result => this.makeAccessTokenRequest(this.configuration!, result.refreshToken!)) .then(() => log('All done.')); } diff --git a/src/node_support/node_request_handler.ts b/src/node_support/node_request_handler.ts index 9349558..d6ff270 100644 --- a/src/node_support/node_request_handler.ts +++ b/src/node_support/node_request_handler.ts @@ -17,7 +17,8 @@ import * as Http from 'http'; import * as Url from 'url'; import {AuthorizationRequest} from '../authorization_request'; import {AuthorizationRequestHandler, AuthorizationRequestResponse} from '../authorization_request_handler'; -import {AuthorizationError, AuthorizationResponse} from '../authorization_response'; +import {AuthorizationResponse} from '../authorization_response'; +import {AuthorizationError} from '../authorization_management_response'; import {AuthorizationServiceConfiguration} from '../authorization_service_configuration'; import {Crypto} from '../crypto_utils'; import {log} from '../logger'; diff --git a/src/redirect_based_handler.ts b/src/redirect_based_handler.ts index 7f08a7e..514248e 100644 --- a/src/redirect_based_handler.ts +++ b/src/redirect_based_handler.ts @@ -12,10 +12,10 @@ * limitations under the License. */ +import {AuthorizationError} from './authorization_management_response'; import {AuthorizationRequest} from './authorization_request'; import {AuthorizationRequestHandler, AuthorizationRequestResponse} from './authorization_request_handler'; import {AuthorizationResponse} from './authorization_response' -import {AuthorizationError} from './authorization_management_response'; import {AuthorizationServiceConfiguration} from './authorization_service_configuration'; import {Crypto, DefaultCrypto} from './crypto_utils'; import {log} from './logger'; From 0881ff3d082aa2e738290674e743fee0f025c42e Mon Sep 17 00:00:00 2001 From: Arsalan Salari Date: Thu, 9 Sep 2021 11:17:36 +0430 Subject: [PATCH 07/13] Refactor RedirectRequestHandler to handle end session Redirect RequestHandler should handler both endsession and authorization flow --- built/authorization_management_request.d.ts | 6 + built/authorization_management_request.js | 23 +++ built/authorization_management_response.d.ts | 26 ++++ built/authorization_management_response.js | 46 ++++++ built/authorization_request.d.ts | 5 +- built/authorization_request.js | 71 +++++++-- built/authorization_request_handler.d.ts | 18 +-- built/authorization_request_handler.js | 26 +--- built/authorization_response.d.ts | 25 +--- built/authorization_response.js | 54 ++++--- built/end_session_request.d.ts | 36 +++++ built/end_session_request.js | 101 +++++++++++++ built/end_session_response.d.ts | 17 +++ built/end_session_response.js | 51 +++++++ built/node_support/node_request_handler.js | 5 +- built/redirect_based_handler.d.ts | 15 +- built/redirect_based_handler.js | 81 ++++++++--- src/app/index.ts | 1 + src/end_session_redirect_based_handler.ts | 145 ------------------- src/redirect_based_handler.ts | 95 +++++++++--- 20 files changed, 560 insertions(+), 287 deletions(-) create mode 100644 built/authorization_management_request.d.ts create mode 100644 built/authorization_management_request.js create mode 100644 built/authorization_management_response.d.ts create mode 100644 built/authorization_management_response.js create mode 100644 built/end_session_request.d.ts create mode 100644 built/end_session_request.js create mode 100644 built/end_session_response.d.ts create mode 100644 built/end_session_response.js delete mode 100644 src/end_session_redirect_based_handler.ts diff --git a/built/authorization_management_request.d.ts b/built/authorization_management_request.d.ts new file mode 100644 index 0000000..3d04ce5 --- /dev/null +++ b/built/authorization_management_request.d.ts @@ -0,0 +1,6 @@ +import { StringMap } from './types'; +export declare abstract class AuthorizationManagementRequest { + abstract state: string; + abstract toJson(): Promise; + abstract toRequestMap(): StringMap; +} diff --git a/built/authorization_management_request.js b/built/authorization_management_request.js new file mode 100644 index 0000000..c6012f8 --- /dev/null +++ b/built/authorization_management_request.js @@ -0,0 +1,23 @@ +"use strict"; +/* + * Copyright 2017 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the + * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.AuthorizationManagementRequest = void 0; +var AuthorizationManagementRequest = /** @class */ (function () { + function AuthorizationManagementRequest() { + } + return AuthorizationManagementRequest; +}()); +exports.AuthorizationManagementRequest = AuthorizationManagementRequest; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aG9yaXphdGlvbl9tYW5hZ2VtZW50X3JlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvYXV0aG9yaXphdGlvbl9tYW5hZ2VtZW50X3JlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7Ozs7Ozs7R0FZRzs7O0FBSUg7SUFBQTtJQVNBLENBQUM7SUFBRCxxQ0FBQztBQUFELENBQUMsQUFURCxJQVNDO0FBVHFCLHdFQUE4QiIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNyBHb29nbGUgSW5jLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7IHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0XG4gKiBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlXG4gKiBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUywgV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlclxuICogZXhwcmVzcyBvciBpbXBsaWVkLiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQge1N0cmluZ01hcH0gZnJvbSAnLi90eXBlcyc7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBdXRob3JpemF0aW9uTWFuYWdlbWVudFJlcXVlc3Qge1xuICBwdWJsaWMgYWJzdHJhY3Qgc3RhdGU6IHN0cmluZztcblxuICAvKlxuICAgKiBTZXJpYWxpemVzIHRoZSByZXF1ZXN0IG9iamVjdCB0byBhIEphdmFTY3JpcHQgb2JqZWN0XG4gICAqL1xuICBwdWJsaWMgYWJzdHJhY3QgdG9Kc29uKCk6IFByb21pc2U8b2JqZWN0PjtcblxuICBwdWJsaWMgYWJzdHJhY3QgdG9SZXF1ZXN0TWFwKCk6IFN0cmluZ01hcDtcbn1cbiJdfQ== \ No newline at end of file diff --git a/built/authorization_management_response.d.ts b/built/authorization_management_response.d.ts new file mode 100644 index 0000000..719147f --- /dev/null +++ b/built/authorization_management_response.d.ts @@ -0,0 +1,26 @@ +/** + * Represents the AuthorizationError as a JSON object. + */ +export interface AuthorizationErrorJson { + error: string; + error_description?: string; + error_uri?: string; + state?: string; +} +export declare abstract class AuthorizationManagementResponse { + abstract state: string; + abstract toJson(): object; +} +/** + * Represents the Authorization error response. + * For more information look at: + * https://tools.ietf.org/html/rfc6749#section-4.1.2.1 + */ +export declare class AuthorizationError { + error: string; + errorDescription?: string; + errorUri?: string; + state?: string; + constructor(error: AuthorizationErrorJson); + toJson(): AuthorizationErrorJson; +} diff --git a/built/authorization_management_response.js b/built/authorization_management_response.js new file mode 100644 index 0000000..f7ff99f --- /dev/null +++ b/built/authorization_management_response.js @@ -0,0 +1,46 @@ +"use strict"; +/* + * Copyright 2017 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the + * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.AuthorizationError = exports.AuthorizationManagementResponse = void 0; +var AuthorizationManagementResponse = /** @class */ (function () { + function AuthorizationManagementResponse() { + } + return AuthorizationManagementResponse; +}()); +exports.AuthorizationManagementResponse = AuthorizationManagementResponse; +/** + * Represents the Authorization error response. + * For more information look at: + * https://tools.ietf.org/html/rfc6749#section-4.1.2.1 + */ +var AuthorizationError = /** @class */ (function () { + function AuthorizationError(error) { + this.error = error.error; + this.errorDescription = error.error_description; + this.errorUri = error.error_uri; + this.state = error.state; + } + AuthorizationError.prototype.toJson = function () { + return { + error: this.error, + error_description: this.errorDescription, + error_uri: this.errorUri, + state: this.state, + }; + }; + return AuthorizationError; +}()); +exports.AuthorizationError = AuthorizationError; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/built/authorization_request.d.ts b/built/authorization_request.d.ts index f77739a..447e34a 100644 --- a/built/authorization_request.d.ts +++ b/built/authorization_request.d.ts @@ -1,5 +1,7 @@ +import { AuthorizationManagementRequest } from './authorization_management_request'; import { Crypto } from './crypto_utils'; import { StringMap } from './types'; +export declare const BUILT_IN_PARAMETERS: string[]; /** * Represents an AuthorizationRequest as JSON. */ @@ -17,7 +19,7 @@ export interface AuthorizationRequestJson { * For more information look at * https://tools.ietf.org/html/rfc6749#section-4.1.1 */ -export declare class AuthorizationRequest { +export declare class AuthorizationRequest extends AuthorizationManagementRequest { private crypto; private usePkce; static RESPONSE_TYPE_TOKEN: string; @@ -40,4 +42,5 @@ export declare class AuthorizationRequest { * Serializes the AuthorizationRequest to a JavaScript Object. */ toJson(): Promise; + toRequestMap(): StringMap; } diff --git a/built/authorization_request.js b/built/authorization_request.js index b9764ff..268d922 100644 --- a/built/authorization_request.js +++ b/built/authorization_request.js @@ -12,10 +12,29 @@ * express or implied. See the License for the specific language governing permissions and * limitations under the License. */ +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -exports.AuthorizationRequest = void 0; +exports.AuthorizationRequest = exports.BUILT_IN_PARAMETERS = void 0; +var authorization_management_request_1 = require("./authorization_management_request"); var crypto_utils_1 = require("./crypto_utils"); var logger_1 = require("./logger"); +// TODO(rahulrav@): add more built in parameters. +/* built in parameters. */ +exports.BUILT_IN_PARAMETERS = ['redirect_uri', 'client_id', 'response_type', 'state', 'scope']; /** * Generates a cryptographically random new state. Useful for CSRF protection. */ @@ -28,7 +47,8 @@ var newState = function (crypto) { * For more information look at * https://tools.ietf.org/html/rfc6749#section-4.1.1 */ -var AuthorizationRequest = /** @class */ (function () { +var AuthorizationRequest = /** @class */ (function (_super) { + __extends(AuthorizationRequest, _super); /** * Constructs a new AuthorizationRequest. * Use a `undefined` value for the `state` parameter, to generate a random @@ -37,16 +57,18 @@ var AuthorizationRequest = /** @class */ (function () { function AuthorizationRequest(request, crypto, usePkce) { if (crypto === void 0) { crypto = new crypto_utils_1.DefaultCrypto(); } if (usePkce === void 0) { usePkce = true; } - this.crypto = crypto; - this.usePkce = usePkce; - this.clientId = request.client_id; - this.redirectUri = request.redirect_uri; - this.scope = request.scope; - this.responseType = request.response_type || AuthorizationRequest.RESPONSE_TYPE_CODE; - this.state = request.state || newState(crypto); - this.extras = request.extras; + var _this = _super.call(this) || this; + _this.crypto = crypto; + _this.usePkce = usePkce; + _this.clientId = request.client_id; + _this.redirectUri = request.redirect_uri; + _this.scope = request.scope; + _this.responseType = request.response_type || AuthorizationRequest.RESPONSE_TYPE_CODE; + _this.state = request.state || newState(crypto); + _this.extras = request.extras; // read internal properties if available - this.internal = request.internal; + _this.internal = request.internal; + return _this; } AuthorizationRequest.prototype.setupCodeVerifier = function () { var _this = this; @@ -90,9 +112,32 @@ var AuthorizationRequest = /** @class */ (function () { }; }); }; + AuthorizationRequest.prototype.toRequestMap = function () { + // build the query string + // coerce to any type for convenience + var requestMap = { + redirect_uri: this.redirectUri, + client_id: this.clientId, + response_type: this.responseType, + state: this.state, + scope: this.scope, + }; + // copy over extras + if (this.extras) { + for (var extra in this.extras) { + if (this.extras.hasOwnProperty(extra)) { + // check before inserting to requestMap + if (exports.BUILT_IN_PARAMETERS.indexOf(extra) < 0) { + requestMap[extra] = this.extras[extra]; + } + } + } + } + return requestMap; + }; AuthorizationRequest.RESPONSE_TYPE_TOKEN = 'token'; AuthorizationRequest.RESPONSE_TYPE_CODE = 'code'; return AuthorizationRequest; -}()); +}(authorization_management_request_1.AuthorizationManagementRequest)); exports.AuthorizationRequest = AuthorizationRequest; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorization_request.js","sourceRoot":"","sources":["../src/authorization_request.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Crypto, DefaultCrypto} from './crypto_utils';\nimport {log} from './logger';\nimport {StringMap} from './types';\n\n/**\n * Represents an AuthorizationRequest as JSON.\n */\nexport interface AuthorizationRequestJson {\n  response_type: string;\n  client_id: string;\n  redirect_uri: string;\n  scope: string;\n  state?: string;\n  extras?: StringMap;\n  internal?: StringMap;\n}\n\n/**\n * Generates a cryptographically random new state. Useful for CSRF protection.\n */\nconst SIZE = 10;  // 10 bytes\nconst newState = function(crypto: Crypto): string {\n  return crypto.generateRandom(SIZE);\n};\n\n/**\n * Represents the AuthorizationRequest.\n * For more information look at\n * https://tools.ietf.org/html/rfc6749#section-4.1.1\n */\nexport class AuthorizationRequest {\n  static RESPONSE_TYPE_TOKEN = 'token';\n  static RESPONSE_TYPE_CODE = 'code';\n\n  // NOTE:\n  // Both redirect_uri and state are actually optional.\n  // However AppAuth is more opionionated, and requires you to use both.\n\n  clientId: string;\n  redirectUri: string;\n  scope: string;\n  responseType: string;\n  state: string;\n  extras?: StringMap;\n  internal?: StringMap;\n  /**\n   * Constructs a new AuthorizationRequest.\n   * Use a `undefined` value for the `state` parameter, to generate a random\n   * state for CSRF protection.\n   */\n  constructor(\n      request: AuthorizationRequestJson,\n      private crypto: Crypto = new DefaultCrypto(),\n      private usePkce: boolean = true) {\n    this.clientId = request.client_id;\n    this.redirectUri = request.redirect_uri;\n    this.scope = request.scope;\n    this.responseType = request.response_type || AuthorizationRequest.RESPONSE_TYPE_CODE;\n    this.state = request.state || newState(crypto);\n    this.extras = request.extras;\n    // read internal properties if available\n    this.internal = request.internal;\n  }\n\n  setupCodeVerifier(): Promise<void> {\n    if (!this.usePkce) {\n      return Promise.resolve();\n    } else {\n      const codeVerifier = this.crypto.generateRandom(128);\n      const challenge: Promise<string|undefined> =\n          this.crypto.deriveChallenge(codeVerifier).catch(error => {\n            log('Unable to generate PKCE challenge. Not using PKCE', error);\n            return undefined;\n          });\n      return challenge.then(result => {\n        if (result) {\n          // keep track of the code used.\n          this.internal = this.internal || {};\n          this.internal['code_verifier'] = codeVerifier;\n          this.extras = this.extras || {};\n          this.extras['code_challenge'] = result;\n          // We always use S256. Plain is not good enough.\n          this.extras['code_challenge_method'] = 'S256';\n        }\n      });\n    }\n  }\n\n  /**\n   * Serializes the AuthorizationRequest to a JavaScript Object.\n   */\n  toJson(): Promise<AuthorizationRequestJson> {\n    // Always make sure that the code verifier is setup when toJson() is called.\n    return this.setupCodeVerifier().then(() => {\n      return {\n        response_type: this.responseType,\n        client_id: this.clientId,\n        redirect_uri: this.redirectUri,\n        scope: this.scope,\n        state: this.state,\n        extras: this.extras,\n        internal: this.internal\n      };\n    });\n  }\n}\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorization_request.js","sourceRoot":"","sources":["../src/authorization_request.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {AuthorizationManagementRequest} from './authorization_management_request';\nimport {Crypto, DefaultCrypto} from './crypto_utils';\nimport {log} from './logger';\nimport {StringMap} from './types';\n\n\n\n// TODO(rahulrav@): add more built in parameters.\n/* built in parameters. */\nexport const BUILT_IN_PARAMETERS = ['redirect_uri', 'client_id', 'response_type', 'state', 'scope'];\n\n/**\n * Represents an AuthorizationRequest as JSON.\n */\nexport interface AuthorizationRequestJson {\n  response_type: string;\n  client_id: string;\n  redirect_uri: string;\n  scope: string;\n  state?: string;\n  extras?: StringMap;\n  internal?: StringMap;\n}\n\n/**\n * Generates a cryptographically random new state. Useful for CSRF protection.\n */\nconst SIZE = 10;  // 10 bytes\nconst newState = function(crypto: Crypto): string {\n  return crypto.generateRandom(SIZE);\n};\n\n/**\n * Represents the AuthorizationRequest.\n * For more information look at\n * https://tools.ietf.org/html/rfc6749#section-4.1.1\n */\nexport class AuthorizationRequest extends AuthorizationManagementRequest {\n  static RESPONSE_TYPE_TOKEN = 'token';\n  static RESPONSE_TYPE_CODE = 'code';\n\n  // NOTE:\n  // Both redirect_uri and state are actually optional.\n  // However AppAuth is more opionionated, and requires you to use both.\n\n  clientId: string;\n  redirectUri: string;\n  scope: string;\n  responseType: string;\n  state: string;\n  extras?: StringMap;\n  internal?: StringMap;\n  /**\n   * Constructs a new AuthorizationRequest.\n   * Use a `undefined` value for the `state` parameter, to generate a random\n   * state for CSRF protection.\n   */\n  constructor(\n      request: AuthorizationRequestJson,\n      private crypto: Crypto = new DefaultCrypto(),\n      private usePkce: boolean = true) {\n    super();\n    this.clientId = request.client_id;\n    this.redirectUri = request.redirect_uri;\n    this.scope = request.scope;\n    this.responseType = request.response_type || AuthorizationRequest.RESPONSE_TYPE_CODE;\n    this.state = request.state || newState(crypto);\n    this.extras = request.extras;\n    // read internal properties if available\n    this.internal = request.internal;\n  }\n\n  setupCodeVerifier(): Promise<void> {\n    if (!this.usePkce) {\n      return Promise.resolve();\n    } else {\n      const codeVerifier = this.crypto.generateRandom(128);\n      const challenge: Promise<string|undefined> =\n          this.crypto.deriveChallenge(codeVerifier).catch(error => {\n            log('Unable to generate PKCE challenge. Not using PKCE', error);\n            return undefined;\n          });\n      return challenge.then(result => {\n        if (result) {\n          // keep track of the code used.\n          this.internal = this.internal || {};\n          this.internal['code_verifier'] = codeVerifier;\n          this.extras = this.extras || {};\n          this.extras['code_challenge'] = result;\n          // We always use S256. Plain is not good enough.\n          this.extras['code_challenge_method'] = 'S256';\n        }\n      });\n    }\n  }\n\n  /**\n   * Serializes the AuthorizationRequest to a JavaScript Object.\n   */\n  toJson(): Promise<AuthorizationRequestJson> {\n    // Always make sure that the code verifier is setup when toJson() is called.\n    return this.setupCodeVerifier().then(() => {\n      return {\n        response_type: this.responseType,\n        client_id: this.clientId,\n        redirect_uri: this.redirectUri,\n        scope: this.scope,\n        state: this.state,\n        extras: this.extras,\n        internal: this.internal\n      };\n    });\n  }\n  toRequestMap(): StringMap {\n    // build the query string\n    // coerce to any type for convenience\n    let requestMap: StringMap = {\n      redirect_uri: this.redirectUri,\n      client_id: this.clientId,\n      response_type: this.responseType,\n      state: this.state,\n      scope: this.scope,\n    };\n\n    // copy over extras\n    if (this.extras) {\n      for (let extra in this.extras) {\n        if (this.extras.hasOwnProperty(extra)) {\n          // check before inserting to requestMap\n          if (BUILT_IN_PARAMETERS.indexOf(extra) < 0) {\n            requestMap[extra] = this.extras[extra];\n          }\n        }\n      }\n    }\n    return requestMap\n  }\n}\n"]} \ No newline at end of file diff --git a/built/authorization_request_handler.d.ts b/built/authorization_request_handler.d.ts index 9d42238..ffe5d80 100644 --- a/built/authorization_request_handler.d.ts +++ b/built/authorization_request_handler.d.ts @@ -1,5 +1,6 @@ -import { AuthorizationRequest } from './authorization_request'; -import { AuthorizationError, AuthorizationResponse } from './authorization_response'; +import { AuthorizationManagementRequest } from './authorization_management_request'; +import { AuthorizationManagementResponse } from './authorization_management_response'; +import { AuthorizationError } from './authorization_management_response'; import { AuthorizationServiceConfiguration } from './authorization_service_configuration'; import { Crypto } from './crypto_utils'; import { QueryStringUtils } from './query_string_utils'; @@ -7,13 +8,13 @@ import { QueryStringUtils } from './query_string_utils'; * This type represents a lambda that can take an AuthorizationRequest, * and an AuthorizationResponse as arguments. */ -export declare type AuthorizationListener = (request: AuthorizationRequest, response: AuthorizationResponse | null, error: AuthorizationError | null) => void; +export declare type AuthorizationListener = (request: AuthorizationManagementRequest, response: AuthorizationManagementResponse | null, error: AuthorizationError | null) => void; /** * Represents a structural type holding both authorization request and response. */ export interface AuthorizationRequestResponse { - request: AuthorizationRequest; - response: AuthorizationResponse | null; + request: AuthorizationManagementRequest; + response: AuthorizationManagementResponse | null; error: AuthorizationError | null; } /** @@ -26,9 +27,8 @@ export declare class AuthorizationNotifier { /** * The authorization complete callback. */ - onAuthorizationComplete(request: AuthorizationRequest, response: AuthorizationResponse | null, error: AuthorizationError | null): void; + onAuthorizationComplete(request: AuthorizationManagementRequest, response: AuthorizationManagementResponse | null, error: AuthorizationError | null): void; } -export declare const BUILT_IN_PARAMETERS: string[]; /** * Defines the interface which is capable of handling an authorization request * using various methods (iframe / popup / different process etc.). @@ -41,7 +41,7 @@ export declare abstract class AuthorizationRequestHandler { /** * A utility method to be able to build the authorization request URL. */ - protected buildRequestUrl(configuration: AuthorizationServiceConfiguration, request: AuthorizationRequest): string; + protected buildRequestUrl(configuration: AuthorizationServiceConfiguration, request: AuthorizationManagementRequest): string; /** * Completes the authorization request if necessary & when possible. */ @@ -53,7 +53,7 @@ export declare abstract class AuthorizationRequestHandler { /** * Makes an authorization request. */ - abstract performAuthorizationRequest(configuration: AuthorizationServiceConfiguration, request: AuthorizationRequest): void; + abstract performAuthorizationRequest(configuration: AuthorizationServiceConfiguration, request: AuthorizationManagementRequest): void; /** * Checks if an authorization flow can be completed, and completes it. * The handler returns a `Promise` if ready, or a `Promise` diff --git a/built/authorization_request_handler.js b/built/authorization_request_handler.js index 01e6dea..2fe8fe7 100644 --- a/built/authorization_request_handler.js +++ b/built/authorization_request_handler.js @@ -13,7 +13,7 @@ * limitations under the License. */ Object.defineProperty(exports, "__esModule", { value: true }); -exports.AuthorizationRequestHandler = exports.BUILT_IN_PARAMETERS = exports.AuthorizationNotifier = void 0; +exports.AuthorizationRequestHandler = exports.AuthorizationNotifier = void 0; var logger_1 = require("./logger"); /** * Authorization Service notifier. @@ -38,9 +38,6 @@ var AuthorizationNotifier = /** @class */ (function () { return AuthorizationNotifier; }()); exports.AuthorizationNotifier = AuthorizationNotifier; -// TODO(rahulrav@): add more built in parameters. -/* built in parameters. */ -exports.BUILT_IN_PARAMETERS = ['redirect_uri', 'client_id', 'response_type', 'state', 'scope']; /** * Defines the interface which is capable of handling an authorization request * using various methods (iframe / popup / different process etc.). @@ -58,24 +55,7 @@ var AuthorizationRequestHandler = /** @class */ (function () { AuthorizationRequestHandler.prototype.buildRequestUrl = function (configuration, request) { // build the query string // coerce to any type for convenience - var requestMap = { - 'redirect_uri': request.redirectUri, - 'client_id': request.clientId, - 'response_type': request.responseType, - 'state': request.state, - 'scope': request.scope - }; - // copy over extras - if (request.extras) { - for (var extra in request.extras) { - if (request.extras.hasOwnProperty(extra)) { - // check before inserting to requestMap - if (exports.BUILT_IN_PARAMETERS.indexOf(extra) < 0) { - requestMap[extra] = request.extras[extra]; - } - } - } - } + var requestMap = request.toRequestMap(); var query = this.utils.stringify(requestMap); var baseUrl = configuration.authorizationEndpoint; var url = baseUrl + "?" + query; @@ -112,4 +92,4 @@ var AuthorizationRequestHandler = /** @class */ (function () { return AuthorizationRequestHandler; }()); exports.AuthorizationRequestHandler = AuthorizationRequestHandler; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorization_request_handler.js","sourceRoot":"","sources":["../src/authorization_request_handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {AuthorizationRequest} from './authorization_request';\nimport {AuthorizationError, AuthorizationResponse} from './authorization_response';\nimport {AuthorizationServiceConfiguration} from './authorization_service_configuration';\nimport {Crypto} from './crypto_utils';\nimport {log} from './logger';\nimport {QueryStringUtils} from './query_string_utils';\nimport {StringMap} from './types';\n\n\n/**\n * This type represents a lambda that can take an AuthorizationRequest,\n * and an AuthorizationResponse as arguments.\n */\nexport type AuthorizationListener =\n    (request: AuthorizationRequest,\n     response: AuthorizationResponse|null,\n     error: AuthorizationError|null) => void;\n\n/**\n * Represents a structural type holding both authorization request and response.\n */\nexport interface AuthorizationRequestResponse {\n  request: AuthorizationRequest;\n  response: AuthorizationResponse|null;\n  error: AuthorizationError|null;\n}\n\n/**\n * Authorization Service notifier.\n * This manages the communication of the AuthorizationResponse to the 3p client.\n */\nexport class AuthorizationNotifier {\n  private listener: AuthorizationListener|null = null;\n\n  setAuthorizationListener(listener: AuthorizationListener) {\n    this.listener = listener;\n  }\n\n  /**\n   * The authorization complete callback.\n   */\n  onAuthorizationComplete(\n      request: AuthorizationRequest,\n      response: AuthorizationResponse|null,\n      error: AuthorizationError|null): void {\n    if (this.listener) {\n      // complete authorization request\n      this.listener(request, response, error);\n    }\n  }\n}\n\n// TODO(rahulrav@): add more built in parameters.\n/* built in parameters. */\nexport const BUILT_IN_PARAMETERS = ['redirect_uri', 'client_id', 'response_type', 'state', 'scope'];\n\n/**\n * Defines the interface which is capable of handling an authorization request\n * using various methods (iframe / popup / different process etc.).\n */\nexport abstract class AuthorizationRequestHandler {\n  constructor(public utils: QueryStringUtils, protected crypto: Crypto) {}\n\n  // notifier send the response back to the client.\n  protected notifier: AuthorizationNotifier|null = null;\n\n  /**\n   * A utility method to be able to build the authorization request URL.\n   */\n  protected buildRequestUrl(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationRequest) {\n    // build the query string\n    // coerce to any type for convenience\n    let requestMap: StringMap = {\n      'redirect_uri': request.redirectUri,\n      'client_id': request.clientId,\n      'response_type': request.responseType,\n      'state': request.state,\n      'scope': request.scope\n    };\n\n    // copy over extras\n    if (request.extras) {\n      for (let extra in request.extras) {\n        if (request.extras.hasOwnProperty(extra)) {\n          // check before inserting to requestMap\n          if (BUILT_IN_PARAMETERS.indexOf(extra) < 0) {\n            requestMap[extra] = request.extras[extra];\n          }\n        }\n      }\n    }\n\n    let query = this.utils.stringify(requestMap);\n    let baseUrl = configuration.authorizationEndpoint;\n    let url = `${baseUrl}?${query}`;\n    return url;\n  }\n\n  /**\n   * Completes the authorization request if necessary & when possible.\n   */\n  completeAuthorizationRequestIfPossible(): Promise<void> {\n    // call complete authorization if possible to see there might\n    // be a response that needs to be delivered.\n    log(`Checking to see if there is an authorization response to be delivered.`);\n    if (!this.notifier) {\n      log(`Notifier is not present on AuthorizationRequest handler.\n          No delivery of result will be possible`)\n    }\n    return this.completeAuthorizationRequest().then(result => {\n      if (!result) {\n        log(`No result is available yet.`);\n      }\n      if (result && this.notifier) {\n        this.notifier.onAuthorizationComplete(result.request, result.response, result.error);\n      }\n    });\n  }\n\n  /**\n   * Sets the default Authorization Service notifier.\n   */\n  setAuthorizationNotifier(notifier: AuthorizationNotifier): AuthorizationRequestHandler {\n    this.notifier = notifier;\n    return this;\n  };\n\n  /**\n   * Makes an authorization request.\n   */\n  abstract performAuthorizationRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationRequest): void;\n\n  /**\n   * Checks if an authorization flow can be completed, and completes it.\n   * The handler returns a `Promise<AuthorizationRequestResponse>` if ready, or a `Promise<null>`\n   * if not ready.\n   */\n  protected abstract completeAuthorizationRequest(): Promise<AuthorizationRequestResponse|null>;\n}\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorization_request_handler.js","sourceRoot":"","sources":["../src/authorization_request_handler.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AAOH,mCAA6B;AAuB7B;;;GAGG;AACH;IAAA;QACU,aAAQ,GAA+B,IAAI,CAAC;IAkBtD,CAAC;IAhBC,wDAAwB,GAAxB,UAAyB,QAA+B;QACtD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,uDAAuB,GAAvB,UACI,OAAuC,EACvC,QAA8C,EAC9C,KAA8B;QAChC,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,iCAAiC;YACjC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;SACzC;IACH,CAAC;IACH,4BAAC;AAAD,CAAC,AAnBD,IAmBC;AAnBY,sDAAqB;AAsBlC;;;GAGG;AACH;IACE,qCAAmB,KAAuB,EAAY,MAAc;QAAjD,UAAK,GAAL,KAAK,CAAkB;QAAY,WAAM,GAAN,MAAM,CAAQ;QAEpE,iDAAiD;QACvC,aAAQ,GAA+B,IAAI,CAAC;IAHiB,CAAC;IAKxE;;OAEG;IACO,qDAAe,GAAzB,UACI,aAAgD,EAChD,OAAuC;QACzC,yBAAyB;QACzB,qCAAqC;QACrC,IAAI,UAAU,GAAc,OAAO,CAAC,YAAY,EAAE,CAAA;QAClD,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAC7C,IAAI,OAAO,GAAG,aAAa,CAAC,qBAAqB,CAAC;QAClD,IAAI,GAAG,GAAM,OAAO,SAAI,KAAO,CAAC;QAChC,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;OAEG;IACH,4EAAsC,GAAtC;QAAA,iBAgBC;QAfC,6DAA6D;QAC7D,4CAA4C;QAC5C,YAAG,CAAC,wEAAwE,CAAC,CAAC;QAC9E,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,YAAG,CAAC,4GACuC,CAAC,CAAA;SAC7C;QACD,OAAO,IAAI,CAAC,4BAA4B,EAAE,CAAC,IAAI,CAAC,UAAA,MAAM;YACpD,IAAI,CAAC,MAAM,EAAE;gBACX,YAAG,CAAC,6BAA6B,CAAC,CAAC;aACpC;YACD,IAAI,MAAM,IAAI,KAAI,CAAC,QAAQ,EAAE;gBAC3B,KAAI,CAAC,QAAQ,CAAC,uBAAuB,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;aACtF;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,8DAAwB,GAAxB,UAAyB,QAA+B;QACtD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IAAA,CAAC;IAeJ,kCAAC;AAAD,CAAC,AA/DD,IA+DC;AA/DqB,kEAA2B","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {AuthorizationManagementRequest} from './authorization_management_request';\nimport {AuthorizationManagementResponse} from './authorization_management_response';\nimport {AuthorizationError} from './authorization_management_response';\nimport {AuthorizationServiceConfiguration} from './authorization_service_configuration';\nimport {Crypto} from './crypto_utils';\nimport {log} from './logger';\nimport {QueryStringUtils} from './query_string_utils';\nimport {StringMap} from './types';\n\n\n/**\n * This type represents a lambda that can take an AuthorizationRequest,\n * and an AuthorizationResponse as arguments.\n */\nexport type AuthorizationListener =\n    (request: AuthorizationManagementRequest,\n     response: AuthorizationManagementResponse|null,\n     error: AuthorizationError|null) => void;\n\n/**\n * Represents a structural type holding both authorization request and response.\n */\nexport interface AuthorizationRequestResponse {\n  request: AuthorizationManagementRequest;\n  response: AuthorizationManagementResponse|null;\n  error: AuthorizationError|null;\n}\n\n/**\n * Authorization Service notifier.\n * This manages the communication of the AuthorizationResponse to the 3p client.\n */\nexport class AuthorizationNotifier {\n  private listener: AuthorizationListener|null = null;\n\n  setAuthorizationListener(listener: AuthorizationListener) {\n    this.listener = listener;\n  }\n\n  /**\n   * The authorization complete callback.\n   */\n  onAuthorizationComplete(\n      request: AuthorizationManagementRequest,\n      response: AuthorizationManagementResponse|null,\n      error: AuthorizationError|null): void {\n    if (this.listener) {\n      // complete authorization request\n      this.listener(request, response, error);\n    }\n  }\n}\n\n\n/**\n * Defines the interface which is capable of handling an authorization request\n * using various methods (iframe / popup / different process etc.).\n */\nexport abstract class AuthorizationRequestHandler {\n  constructor(public utils: QueryStringUtils, protected crypto: Crypto) {}\n\n  // notifier send the response back to the client.\n  protected notifier: AuthorizationNotifier|null = null;\n\n  /**\n   * A utility method to be able to build the authorization request URL.\n   */\n  protected buildRequestUrl(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationManagementRequest) {\n    // build the query string\n    // coerce to any type for convenience\n    let requestMap: StringMap = request.toRequestMap()\n    let query = this.utils.stringify(requestMap);\n    let baseUrl = configuration.authorizationEndpoint;\n    let url = `${baseUrl}?${query}`;\n    return url;\n  }\n\n  /**\n   * Completes the authorization request if necessary & when possible.\n   */\n  completeAuthorizationRequestIfPossible(): Promise<void> {\n    // call complete authorization if possible to see there might\n    // be a response that needs to be delivered.\n    log(`Checking to see if there is an authorization response to be delivered.`);\n    if (!this.notifier) {\n      log(`Notifier is not present on AuthorizationRequest handler.\n          No delivery of result will be possible`)\n    }\n    return this.completeAuthorizationRequest().then(result => {\n      if (!result) {\n        log(`No result is available yet.`);\n      }\n      if (result && this.notifier) {\n        this.notifier.onAuthorizationComplete(result.request, result.response, result.error);\n      }\n    });\n  }\n\n  /**\n   * Sets the default Authorization Service notifier.\n   */\n  setAuthorizationNotifier(notifier: AuthorizationNotifier): AuthorizationRequestHandler {\n    this.notifier = notifier;\n    return this;\n  };\n\n  /**\n   * Makes an authorization request.\n   */\n  abstract performAuthorizationRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationManagementRequest): void;\n\n  /**\n   * Checks if an authorization flow can be completed, and completes it.\n   * The handler returns a `Promise<AuthorizationRequestResponse>` if ready, or a `Promise<null>`\n   * if not ready.\n   */\n  protected abstract completeAuthorizationRequest(): Promise<AuthorizationRequestResponse|null>;\n}\n"]} \ No newline at end of file diff --git a/built/authorization_response.d.ts b/built/authorization_response.d.ts index 9cece73..176593d 100644 --- a/built/authorization_response.d.ts +++ b/built/authorization_response.d.ts @@ -1,3 +1,4 @@ +import { AuthorizationManagementResponse } from './authorization_management_response'; /** * Represents the AuthorizationResponse as a JSON object. */ @@ -5,36 +6,14 @@ export interface AuthorizationResponseJson { code: string; state: string; } -/** - * Represents the AuthorizationError as a JSON object. - */ -export interface AuthorizationErrorJson { - error: string; - error_description?: string; - error_uri?: string; - state?: string; -} /** * Represents the Authorization Response type. * For more information look at * https://tools.ietf.org/html/rfc6749#section-4.1.2 */ -export declare class AuthorizationResponse { +export declare class AuthorizationResponse extends AuthorizationManagementResponse { code: string; state: string; constructor(response: AuthorizationResponseJson); toJson(): AuthorizationResponseJson; } -/** - * Represents the Authorization error response. - * For more information look at: - * https://tools.ietf.org/html/rfc6749#section-4.1.2.1 - */ -export declare class AuthorizationError { - error: string; - errorDescription?: string; - errorUri?: string; - state?: string; - constructor(error: AuthorizationErrorJson); - toJson(): AuthorizationErrorJson; -} diff --git a/built/authorization_response.js b/built/authorization_response.js index 17b5321..ed5bf89 100644 --- a/built/authorization_response.js +++ b/built/authorization_response.js @@ -12,45 +12,41 @@ * express or implied. See the License for the specific language governing permissions and * limitations under the License. */ +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); Object.defineProperty(exports, "__esModule", { value: true }); -exports.AuthorizationError = exports.AuthorizationResponse = void 0; +exports.AuthorizationResponse = void 0; +var authorization_management_response_1 = require("./authorization_management_response"); /** * Represents the Authorization Response type. * For more information look at * https://tools.ietf.org/html/rfc6749#section-4.1.2 */ -var AuthorizationResponse = /** @class */ (function () { +var AuthorizationResponse = /** @class */ (function (_super) { + __extends(AuthorizationResponse, _super); function AuthorizationResponse(response) { - this.code = response.code; - this.state = response.state; + var _this = _super.call(this) || this; + _this.code = response.code; + _this.state = response.state; + return _this; } AuthorizationResponse.prototype.toJson = function () { return { code: this.code, state: this.state }; }; return AuthorizationResponse; -}()); +}(authorization_management_response_1.AuthorizationManagementResponse)); exports.AuthorizationResponse = AuthorizationResponse; -/** - * Represents the Authorization error response. - * For more information look at: - * https://tools.ietf.org/html/rfc6749#section-4.1.2.1 - */ -var AuthorizationError = /** @class */ (function () { - function AuthorizationError(error) { - this.error = error.error; - this.errorDescription = error.error_description; - this.errorUri = error.error_uri; - this.state = error.state; - } - AuthorizationError.prototype.toJson = function () { - return { - error: this.error, - error_description: this.errorDescription, - error_uri: this.errorUri, - state: this.state - }; - }; - return AuthorizationError; -}()); -exports.AuthorizationError = AuthorizationError; -//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/built/end_session_request.d.ts b/built/end_session_request.d.ts new file mode 100644 index 0000000..bd079dd --- /dev/null +++ b/built/end_session_request.d.ts @@ -0,0 +1,36 @@ +import { AuthorizationManagementRequest } from './authorization_management_request'; +import { Crypto } from './crypto_utils'; +import { StringMap } from './types'; +/** + * Represents an EndSessionRequest as JSON. + */ +export interface EndSessionRequestJson { + id_token_hint: string; + post_logout_redirect_uri: string; + state?: string; + extras?: StringMap; +} +export declare const ENDSESSION_BUILT_IN_PARAMETERS: string[]; +/** + * Represents the EndSessionRequest. + * For more information look at + * http://openid.net/specs/openid-connect-session-1_0.html + */ +export declare class EndSessionRequest extends AuthorizationManagementRequest { + private crypto; + idTokenHint: string; + postLogoutRedirectUri: string; + state: string; + extras?: StringMap; + /** + * Constructs a new EndSessionRequest. + * Use a `undefined` value for the `state` parameter, to generate a random + * state for CSRF protection. + */ + constructor(request: EndSessionRequestJson, crypto?: Crypto); + /** + * Serializes the EndSessionRequest to a JavaScript Object. + */ + toJson(): Promise; + toRequestMap(): StringMap; +} diff --git a/built/end_session_request.js b/built/end_session_request.js new file mode 100644 index 0000000..8456d45 --- /dev/null +++ b/built/end_session_request.js @@ -0,0 +1,101 @@ +"use strict"; +/* + * Copyright 2017 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the + * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. See the License for the specific language governing permissions and + * limitations under the License. + */ +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.EndSessionRequest = exports.ENDSESSION_BUILT_IN_PARAMETERS = void 0; +var authorization_management_request_1 = require("./authorization_management_request"); +var crypto_utils_1 = require("./crypto_utils"); +/** + * Generates a cryptographically random new state. Useful for CSRF protection. + */ +var SIZE = 10; // 10 bytes +var newState = function (crypto) { + return crypto.generateRandom(SIZE); +}; +// TODO(rahulrav@): add more built in parameters. +/* built in parameters. */ +exports.ENDSESSION_BUILT_IN_PARAMETERS = ['id_token_hint', 'post_logout_redirect_uri', 'state']; +/** + * Represents the EndSessionRequest. + * For more information look at + * http://openid.net/specs/openid-connect-session-1_0.html + */ +var EndSessionRequest = /** @class */ (function (_super) { + __extends(EndSessionRequest, _super); + /** + * Constructs a new EndSessionRequest. + * Use a `undefined` value for the `state` parameter, to generate a random + * state for CSRF protection. + */ + function EndSessionRequest(request, crypto) { + if (crypto === void 0) { crypto = new crypto_utils_1.DefaultCrypto(); } + var _this = _super.call(this) || this; + _this.crypto = crypto; + _this.idTokenHint = request.id_token_hint; + _this.postLogoutRedirectUri = request.post_logout_redirect_uri; + _this.state = request.state || newState(crypto); + _this.extras = request.extras; + return _this; + } + /** + * Serializes the EndSessionRequest to a JavaScript Object. + */ + EndSessionRequest.prototype.toJson = function () { + return Promise.resolve({ + id_token_hint: this.idTokenHint, + post_logout_redirect_uri: this.postLogoutRedirectUri, + state: this.state, + extras: this.extras + }); + }; + EndSessionRequest.prototype.toRequestMap = function () { + // build the query string + // coerce to any type for convenience + var requestMap = { + 'id_token_hint': this.idTokenHint, + 'post_logout_redirect_uri': this.postLogoutRedirectUri, + 'state': this.state + }; + // copy over extras + if (this.extras) { + for (var extra in this.extras) { + if (this.extras.hasOwnProperty(extra)) { + // check before inserting to requestMap + if (exports.ENDSESSION_BUILT_IN_PARAMETERS.indexOf(extra) < 0) { + requestMap[extra] = this.extras[extra]; + } + } + } + } + return requestMap; + }; + return EndSessionRequest; +}(authorization_management_request_1.AuthorizationManagementRequest)); +exports.EndSessionRequest = EndSessionRequest; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/built/end_session_response.d.ts b/built/end_session_response.d.ts new file mode 100644 index 0000000..2162aa6 --- /dev/null +++ b/built/end_session_response.d.ts @@ -0,0 +1,17 @@ +import { AuthorizationManagementResponse } from './authorization_management_response'; +/** + * Represents the EndSessionResponse as a JSON object. + */ +export interface EndSessionResponseJson { + state: string; +} +/** + * Represents the EndSession Response type. + * For more information look at + * http://openid.net/specs/openid-connect-session-1_0.html + */ +export declare class EndSessionResponse extends AuthorizationManagementResponse { + state: string; + constructor(response: EndSessionResponseJson); + toJson(): EndSessionResponseJson; +} diff --git a/built/end_session_response.js b/built/end_session_response.js new file mode 100644 index 0000000..a3e42f2 --- /dev/null +++ b/built/end_session_response.js @@ -0,0 +1,51 @@ +"use strict"; +/* + * Copyright 2017 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the + * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. See the License for the specific language governing permissions and + * limitations under the License. + */ +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.EndSessionResponse = void 0; +var authorization_management_response_1 = require("./authorization_management_response"); +/** + * Represents the EndSession Response type. + * For more information look at + * http://openid.net/specs/openid-connect-session-1_0.html + */ +var EndSessionResponse = /** @class */ (function (_super) { + __extends(EndSessionResponse, _super); + function EndSessionResponse(response) { + var _this = _super.call(this) || this; + _this.state = response.state; + return _this; + } + EndSessionResponse.prototype.toJson = function () { + return { state: this.state }; + }; + return EndSessionResponse; +}(authorization_management_response_1.AuthorizationManagementResponse)); +exports.EndSessionResponse = EndSessionResponse; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/built/node_support/node_request_handler.js b/built/node_support/node_request_handler.js index 079980f..c26af31 100644 --- a/built/node_support/node_request_handler.js +++ b/built/node_support/node_request_handler.js @@ -34,6 +34,7 @@ var Http = require("http"); var Url = require("url"); var authorization_request_handler_1 = require("../authorization_request_handler"); var authorization_response_1 = require("../authorization_response"); +var authorization_management_response_1 = require("../authorization_management_response"); var logger_1 = require("../logger"); var query_string_utils_1 = require("../query_string_utils"); var crypto_utils_1 = require("./crypto_utils"); @@ -88,7 +89,7 @@ var NodeBasedHandler = /** @class */ (function (_super) { // get additional optional info. var errorUri = searchParams.get('error_uri') || undefined; var errorDescription = searchParams.get('error_description') || undefined; - authorizationError = new authorization_response_1.AuthorizationError({ error: error, error_description: errorDescription, error_uri: errorUri, state: state }); + authorizationError = new authorization_management_response_1.AuthorizationError({ error: error, error_description: errorDescription, error_uri: errorUri, state: state }); } else { authorizationResponse = new authorization_response_1.AuthorizationResponse({ code: code, state: state }); @@ -136,4 +137,4 @@ var NodeBasedHandler = /** @class */ (function (_super) { return NodeBasedHandler; }(authorization_request_handler_1.AuthorizationRequestHandler)); exports.NodeBasedHandler = NodeBasedHandler; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node_request_handler.js","sourceRoot":"","sources":["../../src/node_support/node_request_handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {EventEmitter} from 'events';\nimport * as Http from 'http';\nimport * as Url from 'url';\nimport {AuthorizationRequest} from '../authorization_request';\nimport {AuthorizationRequestHandler, AuthorizationRequestResponse} from '../authorization_request_handler';\nimport {AuthorizationError, AuthorizationResponse} from '../authorization_response';\nimport {AuthorizationServiceConfiguration} from '../authorization_service_configuration';\nimport {Crypto} from '../crypto_utils';\nimport {log} from '../logger';\nimport {BasicQueryStringUtils, QueryStringUtils} from '../query_string_utils';\nimport {NodeCrypto} from './crypto_utils';\n\n\n// TypeScript typings for `opener` are not correct and do not export it as module\nimport opener = require('opener');\n\nclass ServerEventsEmitter extends EventEmitter {\n  static ON_UNABLE_TO_START = 'unable_to_start';\n  static ON_AUTHORIZATION_RESPONSE = 'authorization_response';\n}\n\nexport class NodeBasedHandler extends AuthorizationRequestHandler {\n  // the handle to the current authorization request\n  authorizationPromise: Promise<AuthorizationRequestResponse|null>|null = null;\n\n  constructor(\n      // default to port 8000\n      public httpServerPort = 8000,\n      utils: QueryStringUtils = new BasicQueryStringUtils(),\n      crypto: Crypto = new NodeCrypto()) {\n    super(utils, crypto);\n  }\n\n  performAuthorizationRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationRequest) {\n    // use opener to launch a web browser and start the authorization flow.\n    // start a web server to handle the authorization response.\n    const emitter = new ServerEventsEmitter();\n\n    const requestHandler = (httpRequest: Http.IncomingMessage, response: Http.ServerResponse) => {\n      if (!httpRequest.url) {\n        return;\n      }\n\n      const url = Url.parse(httpRequest.url);\n      const searchParams = new Url.URLSearchParams(url.query || '');\n\n      const state = searchParams.get('state') || undefined;\n      const code = searchParams.get('code');\n      const error = searchParams.get('error');\n\n      if (!state && !code && !error) {\n        // ignore irrelevant requests (e.g. favicon.ico)\n        return;\n      }\n\n      log('Handling Authorization Request ', searchParams, state, code, error);\n      let authorizationResponse: AuthorizationResponse|null = null;\n      let authorizationError: AuthorizationError|null = null;\n      if (error) {\n        log('error');\n        // get additional optional info.\n        const errorUri = searchParams.get('error_uri') || undefined;\n        const errorDescription = searchParams.get('error_description') || undefined;\n        authorizationError = new AuthorizationError(\n            {error: error, error_description: errorDescription, error_uri: errorUri, state: state});\n      } else {\n        authorizationResponse = new AuthorizationResponse({code: code!, state: state!});\n      }\n      const completeResponse = {\n        request,\n        response: authorizationResponse,\n        error: authorizationError\n      } as AuthorizationRequestResponse;\n      emitter.emit(ServerEventsEmitter.ON_AUTHORIZATION_RESPONSE, completeResponse);\n      response.end('Close your browser to continue');\n    };\n\n    this.authorizationPromise = new Promise<AuthorizationRequestResponse>((resolve, reject) => {\n      emitter.once(ServerEventsEmitter.ON_UNABLE_TO_START, () => {\n        reject(`Unable to create HTTP server at port ${this.httpServerPort}`);\n      });\n      emitter.once(ServerEventsEmitter.ON_AUTHORIZATION_RESPONSE, (result: any) => {\n        server.close();\n        // resolve pending promise\n        resolve(result as AuthorizationRequestResponse);\n        // complete authorization flow\n        this.completeAuthorizationRequestIfPossible();\n      });\n    });\n\n    let server: Http.Server;\n    request.setupCodeVerifier()\n        .then(() => {\n          server = Http.createServer(requestHandler);\n          server.listen(this.httpServerPort);\n          const url = this.buildRequestUrl(configuration, request);\n          log('Making a request to ', request, url);\n          opener(url);\n        })\n        .catch((error) => {\n          log('Something bad happened ', error);\n          emitter.emit(ServerEventsEmitter.ON_UNABLE_TO_START);\n        });\n  }\n\n  protected completeAuthorizationRequest(): Promise<AuthorizationRequestResponse|null> {\n    if (!this.authorizationPromise) {\n      return Promise.reject(\n          'No pending authorization request. Call performAuthorizationRequest() ?');\n    }\n\n    return this.authorizationPromise;\n  }\n}\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node_request_handler.js","sourceRoot":"","sources":["../../src/node_support/node_request_handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {EventEmitter} from 'events';\nimport * as Http from 'http';\nimport * as Url from 'url';\nimport {AuthorizationRequest} from '../authorization_request';\nimport {AuthorizationRequestHandler, AuthorizationRequestResponse} from '../authorization_request_handler';\nimport {AuthorizationResponse} from '../authorization_response';\nimport {AuthorizationError} from '../authorization_management_response';\nimport {AuthorizationServiceConfiguration} from '../authorization_service_configuration';\nimport {Crypto} from '../crypto_utils';\nimport {log} from '../logger';\nimport {BasicQueryStringUtils, QueryStringUtils} from '../query_string_utils';\nimport {NodeCrypto} from './crypto_utils';\n\n\n// TypeScript typings for `opener` are not correct and do not export it as module\nimport opener = require('opener');\n\nclass ServerEventsEmitter extends EventEmitter {\n  static ON_UNABLE_TO_START = 'unable_to_start';\n  static ON_AUTHORIZATION_RESPONSE = 'authorization_response';\n}\n\nexport class NodeBasedHandler extends AuthorizationRequestHandler {\n  // the handle to the current authorization request\n  authorizationPromise: Promise<AuthorizationRequestResponse|null>|null = null;\n\n  constructor(\n      // default to port 8000\n      public httpServerPort = 8000,\n      utils: QueryStringUtils = new BasicQueryStringUtils(),\n      crypto: Crypto = new NodeCrypto()) {\n    super(utils, crypto);\n  }\n\n  performAuthorizationRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationRequest) {\n    // use opener to launch a web browser and start the authorization flow.\n    // start a web server to handle the authorization response.\n    const emitter = new ServerEventsEmitter();\n\n    const requestHandler = (httpRequest: Http.IncomingMessage, response: Http.ServerResponse) => {\n      if (!httpRequest.url) {\n        return;\n      }\n\n      const url = Url.parse(httpRequest.url);\n      const searchParams = new Url.URLSearchParams(url.query || '');\n\n      const state = searchParams.get('state') || undefined;\n      const code = searchParams.get('code');\n      const error = searchParams.get('error');\n\n      if (!state && !code && !error) {\n        // ignore irrelevant requests (e.g. favicon.ico)\n        return;\n      }\n\n      log('Handling Authorization Request ', searchParams, state, code, error);\n      let authorizationResponse: AuthorizationResponse|null = null;\n      let authorizationError: AuthorizationError|null = null;\n      if (error) {\n        log('error');\n        // get additional optional info.\n        const errorUri = searchParams.get('error_uri') || undefined;\n        const errorDescription = searchParams.get('error_description') || undefined;\n        authorizationError = new AuthorizationError(\n            {error: error, error_description: errorDescription, error_uri: errorUri, state: state});\n      } else {\n        authorizationResponse = new AuthorizationResponse({code: code!, state: state!});\n      }\n      const completeResponse = {\n        request,\n        response: authorizationResponse,\n        error: authorizationError\n      } as AuthorizationRequestResponse;\n      emitter.emit(ServerEventsEmitter.ON_AUTHORIZATION_RESPONSE, completeResponse);\n      response.end('Close your browser to continue');\n    };\n\n    this.authorizationPromise = new Promise<AuthorizationRequestResponse>((resolve, reject) => {\n      emitter.once(ServerEventsEmitter.ON_UNABLE_TO_START, () => {\n        reject(`Unable to create HTTP server at port ${this.httpServerPort}`);\n      });\n      emitter.once(ServerEventsEmitter.ON_AUTHORIZATION_RESPONSE, (result: any) => {\n        server.close();\n        // resolve pending promise\n        resolve(result as AuthorizationRequestResponse);\n        // complete authorization flow\n        this.completeAuthorizationRequestIfPossible();\n      });\n    });\n\n    let server: Http.Server;\n    request.setupCodeVerifier()\n        .then(() => {\n          server = Http.createServer(requestHandler);\n          server.listen(this.httpServerPort);\n          const url = this.buildRequestUrl(configuration, request);\n          log('Making a request to ', request, url);\n          opener(url);\n        })\n        .catch((error) => {\n          log('Something bad happened ', error);\n          emitter.emit(ServerEventsEmitter.ON_UNABLE_TO_START);\n        });\n  }\n\n  protected completeAuthorizationRequest(): Promise<AuthorizationRequestResponse|null> {\n    if (!this.authorizationPromise) {\n      return Promise.reject(\n          'No pending authorization request. Call performAuthorizationRequest() ?');\n    }\n\n    return this.authorizationPromise;\n  }\n}\n"]} \ No newline at end of file diff --git a/built/redirect_based_handler.d.ts b/built/redirect_based_handler.d.ts index 5fcdabc..4c3ecb0 100644 --- a/built/redirect_based_handler.d.ts +++ b/built/redirect_based_handler.d.ts @@ -2,6 +2,7 @@ import { AuthorizationRequest } from './authorization_request'; import { AuthorizationRequestHandler, AuthorizationRequestResponse } from './authorization_request_handler'; import { AuthorizationServiceConfiguration } from './authorization_service_configuration'; import { Crypto } from './crypto_utils'; +import { EndSessionRequest } from './end_session_request'; import { BasicQueryStringUtils } from './query_string_utils'; import { StorageBackend } from './storage'; import { LocationLike } from './types'; @@ -14,9 +15,21 @@ export declare class RedirectRequestHandler extends AuthorizationRequestHandler locationLike: LocationLike; constructor(storageBackend?: StorageBackend, utils?: BasicQueryStringUtils, locationLike?: LocationLike, crypto?: Crypto); performAuthorizationRequest(configuration: AuthorizationServiceConfiguration, request: AuthorizationRequest): void; + performEndSessionRequest(configuration: AuthorizationServiceConfiguration, request: EndSessionRequest): void; + private performRequest; /** * Attempts to introspect the contents of storage backend and completes the - * request. + * authorization request. */ protected completeAuthorizationRequest(): Promise; + /** + * Attempts to introspect the contents of storage backend and completes the + * end session request. + */ + protected completeEndSessionRequest(): Promise; + /** + * Attempts to introspect the contents of storage backend and completes the + * request. + */ + private completeRequest; } diff --git a/built/redirect_based_handler.js b/built/redirect_based_handler.js index fc54f68..25001c5 100644 --- a/built/redirect_based_handler.js +++ b/built/redirect_based_handler.js @@ -29,23 +29,31 @@ var __extends = (this && this.__extends) || (function () { })(); Object.defineProperty(exports, "__esModule", { value: true }); exports.RedirectRequestHandler = void 0; +var authorization_management_response_1 = require("./authorization_management_response"); var authorization_request_1 = require("./authorization_request"); var authorization_request_handler_1 = require("./authorization_request_handler"); var authorization_response_1 = require("./authorization_response"); var crypto_utils_1 = require("./crypto_utils"); +var end_session_request_1 = require("./end_session_request"); +var end_session_response_1 = require("./end_session_response"); var logger_1 = require("./logger"); var query_string_utils_1 = require("./query_string_utils"); var storage_1 = require("./storage"); +var RequestTypes; +(function (RequestTypes) { + RequestTypes["endSession"] = "end_session"; + RequestTypes["authorization"] = "authorization"; +})(RequestTypes || (RequestTypes = {})); /** key for authorization request. */ -var authorizationRequestKey = function (handle) { - return handle + "_appauth_authorization_request"; +var requestKey = function (handle, requestType) { + return handle + "_appauth_" + requestType + "_request"; }; /** key for authorization service configuration */ -var authorizationServiceConfigurationKey = function (handle) { - return handle + "_appauth_authorization_service_configuration"; +var serviceConfigurationKey = function (handle, requestType) { + return handle + "_appauth_" + requestType + "_service_configuration"; }; /** key in local storage which represents the current authorization request. */ -var AUTHORIZATION_REQUEST_HANDLE_KEY = 'appauth_current_authorization_request'; +var REQUEST_HANDLE_KEY = function (requestType) { return "appauth_current_" + requestType + "_request"; }; /** * Represents an AuthorizationRequestHandler which uses a standard * redirect based code flow. @@ -67,16 +75,23 @@ var RedirectRequestHandler = /** @class */ (function (_super) { return _this; } RedirectRequestHandler.prototype.performAuthorizationRequest = function (configuration, request) { + this.performRequest(configuration, request, RequestTypes.authorization); + }; + RedirectRequestHandler.prototype.performEndSessionRequest = function (configuration, request) { + this.performRequest(configuration, request, RequestTypes.endSession); + }; + RedirectRequestHandler.prototype.performRequest = function (configuration, request, requestType) { var _this = this; + if (requestType === void 0) { requestType = RequestTypes.authorization; } var handle = this.crypto.generateRandom(10); // before you make request, persist all request related data in local storage. var persisted = Promise.all([ - this.storageBackend.setItem(AUTHORIZATION_REQUEST_HANDLE_KEY, handle), + this.storageBackend.setItem(REQUEST_HANDLE_KEY(requestType), handle), // Calling toJson() adds in the code & challenge when possible request.toJson().then(function (result) { - return _this.storageBackend.setItem(authorizationRequestKey(handle), JSON.stringify(result)); + return _this.storageBackend.setItem(requestKey(handle, requestType), JSON.stringify(result)); }), - this.storageBackend.setItem(authorizationServiceConfigurationKey(handle), JSON.stringify(configuration.toJson())), + this.storageBackend.setItem(serviceConfigurationKey(handle, requestType), JSON.stringify(configuration.toJson())), ]); persisted.then(function () { // make the redirect request @@ -87,21 +102,37 @@ var RedirectRequestHandler = /** @class */ (function (_super) { }; /** * Attempts to introspect the contents of storage backend and completes the - * request. + * authorization request. */ RedirectRequestHandler.prototype.completeAuthorizationRequest = function () { + return this.completeRequest(RequestTypes.authorization); + }; + /** + * Attempts to introspect the contents of storage backend and completes the + * end session request. + */ + RedirectRequestHandler.prototype.completeEndSessionRequest = function () { + return this.completeRequest(RequestTypes.endSession); + }; + /** + * Attempts to introspect the contents of storage backend and completes the + * request. + */ + RedirectRequestHandler.prototype.completeRequest = function (requestType) { var _this = this; // TODO(rahulrav@): handle authorization errors. - return this.storageBackend.getItem(AUTHORIZATION_REQUEST_HANDLE_KEY).then(function (handle) { + return this.storageBackend.getItem(REQUEST_HANDLE_KEY(requestType)).then(function (handle) { if (handle) { // we have a pending request. // fetch authorization request, and check state return _this.storageBackend - .getItem(authorizationRequestKey(handle)) + .getItem(requestKey(handle, requestType)) // requires a corresponding instance of result - // TODO(rahulrav@): check for inconsitent state here + // TODO(rahulrav@): check for inconsistent state here .then(function (result) { return JSON.parse(result); }) - .then(function (json) { return new authorization_request_1.AuthorizationRequest(json); }) + .then(function (json) { return requestType === RequestTypes.authorization ? + new authorization_request_1.AuthorizationRequest(json) : + new end_session_request_1.EndSessionRequest(json); }) .then(function (request) { // check redirect_uri and state var currentUri = "" + _this.locationLike.origin + _this.locationLike.pathname; @@ -109,7 +140,12 @@ var RedirectRequestHandler = /** @class */ (function (_super) { var state = queryParams['state']; var code = queryParams['code']; var error = queryParams['error']; - logger_1.log('Potential authorization request ', currentUri, queryParams, state, code, error); + if (requestType === RequestTypes.authorization) { + logger_1.log('Potential authorization request ', currentUri, queryParams, state, code, error); + } + else { + logger_1.log('Potential end session request ', currentUri, queryParams, state, error); + } var shouldNotify = state === request.state; var authorizationResponse = null; var authorizationError = null; @@ -118,7 +154,7 @@ var RedirectRequestHandler = /** @class */ (function (_super) { // get additional optional info. var errorUri = queryParams['error_uri']; var errorDescription = queryParams['error_description']; - authorizationError = new authorization_response_1.AuthorizationError({ + authorizationError = new authorization_management_response_1.AuthorizationError({ error: error, error_description: errorDescription, error_uri: errorUri, @@ -126,14 +162,19 @@ var RedirectRequestHandler = /** @class */ (function (_super) { }); } else { - authorizationResponse = new authorization_response_1.AuthorizationResponse({ code: code, state: state }); + if (requestType === RequestTypes.authorization) { + authorizationResponse = new authorization_response_1.AuthorizationResponse({ code: code, state: state }); + } + else if (requestType === RequestTypes.endSession) { + authorizationResponse = new end_session_response_1.EndSessionResponse({ state: state }); + } } // cleanup state return Promise .all([ - _this.storageBackend.removeItem(AUTHORIZATION_REQUEST_HANDLE_KEY), - _this.storageBackend.removeItem(authorizationRequestKey(handle)), - _this.storageBackend.removeItem(authorizationServiceConfigurationKey(handle)) + _this.storageBackend.removeItem(REQUEST_HANDLE_KEY(requestType)), + _this.storageBackend.removeItem(requestKey(handle, requestType)), + _this.storageBackend.removeItem(serviceConfigurationKey(handle, requestType)) ]) .then(function () { logger_1.log('Delivering authorization response'); @@ -158,4 +199,4 @@ var RedirectRequestHandler = /** @class */ (function (_super) { return RedirectRequestHandler; }(authorization_request_handler_1.AuthorizationRequestHandler)); exports.RedirectRequestHandler = RedirectRequestHandler; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redirect_based_handler.js","sourceRoot":"","sources":["../src/redirect_based_handler.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;;;;;;;;;;;;;;;;AAEH,iEAA6D;AAC7D,iFAA0G;AAC1G,mEAAkF;AAElF,+CAAqD;AACrD,mCAA6B;AAC7B,2DAA2D;AAC3D,qCAA8D;AAI9D,qCAAqC;AACrC,IAAM,uBAAuB,GACzB,UAAC,MAAc;IACb,OAAU,MAAM,mCAAgC,CAAC;AACnD,CAAC,CAAA;AAEL,kDAAkD;AAClD,IAAM,oCAAoC,GACtC,UAAC,MAAc;IACb,OAAU,MAAM,iDAA8C,CAAC;AACjE,CAAC,CAAA;AAEL,+EAA+E;AAC/E,IAAM,gCAAgC,GAAG,uCAAuC,CAAC;AAEjF;;;GAGG;AACH;IAA4C,0CAA2B;IACrE;IACI,mCAAmC;IACnC,qEAAqE;IACrE,2BAA2B;IACpB,cAA0D,EACjE,KAAmC,EAC5B,YAA4C,EACnD,MAAoC;QAH7B,+BAAA,EAAA,qBAAqC,6BAAmB,EAAE;QACjE,sBAAA,EAAA,YAAY,0CAAqB,EAAE;QAC5B,6BAAA,EAAA,eAA6B,MAAM,CAAC,QAAQ;QACnD,uBAAA,EAAA,aAAqB,4BAAa,EAAE;QAPxC,YAQE,kBAAM,KAAK,EAAE,MAAM,CAAC,SACrB;QALU,oBAAc,GAAd,cAAc,CAA4C;QAE1D,kBAAY,GAAZ,YAAY,CAAgC;;IAGvD,CAAC;IAED,4DAA2B,GAA3B,UACI,aAAgD,EAChD,OAA6B;QAFjC,iBAsBC;QAnBC,IAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;QAE9C,8EAA8E;QAC9E,IAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC;YAC5B,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,gCAAgC,EAAE,MAAM,CAAC;YACrE,8DAA8D;YAC9D,OAAO,CAAC,MAAM,EAAE,CAAC,IAAI,CACjB,UAAA,MAAM;gBACF,OAAA,KAAI,CAAC,cAAc,CAAC,OAAO,CAAC,uBAAuB,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YAApF,CAAoF,CAAC;YAC7F,IAAI,CAAC,cAAc,CAAC,OAAO,CACvB,oCAAoC,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;SAC1F,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC;YACb,4BAA4B;YAC5B,IAAI,GAAG,GAAG,KAAI,CAAC,eAAe,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;YACvD,YAAG,CAAC,sBAAsB,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;YAC1C,KAAI,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAChC,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACO,6DAA4B,GAAtC;QAAA,iBA6DC;QA5DC,gDAAgD;QAChD,OAAO,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC,IAAI,CAAC,UAAA,MAAM;YAC9E,IAAI,MAAM,EAAE;gBACV,6BAA6B;gBAC7B,+CAA+C;gBAC/C,OAAO,KAAI,CAAC,cAAc;qBACrB,OAAO,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC;oBACzC,8CAA8C;oBAC9C,oDAAoD;qBACnD,IAAI,CAAC,UAAA,MAAM,IAAI,OAAA,IAAI,CAAC,KAAK,CAAC,MAAO,CAAC,EAAnB,CAAmB,CAAC;qBACnC,IAAI,CAAC,UAAA,IAAI,IAAI,OAAA,IAAI,4CAAoB,CAAC,IAAI,CAAC,EAA9B,CAA8B,CAAC;qBAC5C,IAAI,CAAC,UAAA,OAAO;oBACX,+BAA+B;oBAC/B,IAAI,UAAU,GAAG,KAAG,KAAI,CAAC,YAAY,CAAC,MAAM,GAAG,KAAI,CAAC,YAAY,CAAC,QAAU,CAAC;oBAC5E,IAAI,WAAW,GAAG,KAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAI,CAAC,YAAY,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;oBAC3E,IAAI,KAAK,GAAqB,WAAW,CAAC,OAAO,CAAC,CAAC;oBACnD,IAAI,IAAI,GAAqB,WAAW,CAAC,MAAM,CAAC,CAAC;oBACjD,IAAI,KAAK,GAAqB,WAAW,CAAC,OAAO,CAAC,CAAC;oBACnD,YAAG,CAAC,kCAAkC,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;oBACrF,IAAI,YAAY,GAAG,KAAK,KAAK,OAAO,CAAC,KAAK,CAAC;oBAC3C,IAAI,qBAAqB,GAA+B,IAAI,CAAC;oBAC7D,IAAI,kBAAkB,GAA4B,IAAI,CAAC;oBACvD,IAAI,YAAY,EAAE;wBAChB,IAAI,KAAK,EAAE;4BACT,gCAAgC;4BAChC,IAAI,QAAQ,GAAG,WAAW,CAAC,WAAW,CAAC,CAAC;4BACxC,IAAI,gBAAgB,GAAG,WAAW,CAAC,mBAAmB,CAAC,CAAC;4BACxD,kBAAkB,GAAG,IAAI,2CAAkB,CAAC;gCAC1C,KAAK,EAAE,KAAK;gCACZ,iBAAiB,EAAE,gBAAgB;gCACnC,SAAS,EAAE,QAAQ;gCACnB,KAAK,EAAE,KAAK;6BACb,CAAC,CAAC;yBACJ;6BAAM;4BACL,qBAAqB,GAAG,IAAI,8CAAqB,CAAC,EAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAC,CAAC,CAAC;yBAC/E;wBACD,gBAAgB;wBAChB,OAAO,OAAO;6BACT,GAAG,CAAC;4BACH,KAAI,CAAC,cAAc,CAAC,UAAU,CAAC,gCAAgC,CAAC;4BAChE,KAAI,CAAC,cAAc,CAAC,UAAU,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC;4BAC/D,KAAI,CAAC,cAAc,CAAC,UAAU,CAAC,oCAAoC,CAAC,MAAM,CAAC,CAAC;yBAC7E,CAAC;6BACD,IAAI,CAAC;4BACJ,YAAG,CAAC,mCAAmC,CAAC,CAAC;4BACzC,OAAO;gCACL,OAAO,EAAE,OAAO;gCAChB,QAAQ,EAAE,qBAAqB;gCAC/B,KAAK,EAAE,kBAAkB;6BACM,CAAC;wBACpC,CAAC,CAAC,CAAC;qBACR;yBAAM;wBACL,YAAG,CAAC,wDAAwD,CAAC,CAAC;wBAC9D,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;qBAC9B;gBACH,CAAC,CAAC,CAAC;aACR;iBAAM;gBACL,OAAO,IAAI,CAAC;aACb;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IACH,6BAAC;AAAD,CAAC,AAtGD,CAA4C,2DAA2B,GAsGtE;AAtGY,wDAAsB","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {AuthorizationRequest} from './authorization_request';\nimport {AuthorizationRequestHandler, AuthorizationRequestResponse} from './authorization_request_handler';\nimport {AuthorizationError, AuthorizationResponse} from './authorization_response'\nimport {AuthorizationServiceConfiguration} from './authorization_service_configuration';\nimport {Crypto, DefaultCrypto} from './crypto_utils';\nimport {log} from './logger';\nimport {BasicQueryStringUtils} from './query_string_utils';\nimport {LocalStorageBackend, StorageBackend} from './storage';\nimport {LocationLike} from './types';\n\n\n/** key for authorization request. */\nconst authorizationRequestKey =\n    (handle: string) => {\n      return `${handle}_appauth_authorization_request`;\n    }\n\n/** key for authorization service configuration */\nconst authorizationServiceConfigurationKey =\n    (handle: string) => {\n      return `${handle}_appauth_authorization_service_configuration`;\n    }\n\n/** key in local storage which represents the current authorization request. */\nconst AUTHORIZATION_REQUEST_HANDLE_KEY = 'appauth_current_authorization_request';\n\n/**\n * Represents an AuthorizationRequestHandler which uses a standard\n * redirect based code flow.\n */\nexport class RedirectRequestHandler extends AuthorizationRequestHandler {\n  constructor(\n      // use the provided storage backend\n      // or initialize local storage with the default storage backend which\n      // uses window.localStorage\n      public storageBackend: StorageBackend = new LocalStorageBackend(),\n      utils = new BasicQueryStringUtils(),\n      public locationLike: LocationLike = window.location,\n      crypto: Crypto = new DefaultCrypto()) {\n    super(utils, crypto);\n  }\n\n  performAuthorizationRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationRequest) {\n    const handle = this.crypto.generateRandom(10);\n\n    // before you make request, persist all request related data in local storage.\n    const persisted = Promise.all([\n      this.storageBackend.setItem(AUTHORIZATION_REQUEST_HANDLE_KEY, handle),\n      // Calling toJson() adds in the code & challenge when possible\n      request.toJson().then(\n          result =>\n              this.storageBackend.setItem(authorizationRequestKey(handle), JSON.stringify(result))),\n      this.storageBackend.setItem(\n          authorizationServiceConfigurationKey(handle), JSON.stringify(configuration.toJson())),\n    ]);\n\n    persisted.then(() => {\n      // make the redirect request\n      let url = this.buildRequestUrl(configuration, request);\n      log('Making a request to ', request, url);\n      this.locationLike.assign(url);\n    });\n  }\n\n  /**\n   * Attempts to introspect the contents of storage backend and completes the\n   * request.\n   */\n  protected completeAuthorizationRequest(): Promise<AuthorizationRequestResponse|null> {\n    // TODO(rahulrav@): handle authorization errors.\n    return this.storageBackend.getItem(AUTHORIZATION_REQUEST_HANDLE_KEY).then(handle => {\n      if (handle) {\n        // we have a pending request.\n        // fetch authorization request, and check state\n        return this.storageBackend\n            .getItem(authorizationRequestKey(handle))\n            // requires a corresponding instance of result\n            // TODO(rahulrav@): check for inconsitent state here\n            .then(result => JSON.parse(result!))\n            .then(json => new AuthorizationRequest(json))\n            .then(request => {\n              // check redirect_uri and state\n              let currentUri = `${this.locationLike.origin}${this.locationLike.pathname}`;\n              let queryParams = this.utils.parse(this.locationLike, true /* use hash */);\n              let state: string|undefined = queryParams['state'];\n              let code: string|undefined = queryParams['code'];\n              let error: string|undefined = queryParams['error'];\n              log('Potential authorization request ', currentUri, queryParams, state, code, error);\n              let shouldNotify = state === request.state;\n              let authorizationResponse: AuthorizationResponse|null = null;\n              let authorizationError: AuthorizationError|null = null;\n              if (shouldNotify) {\n                if (error) {\n                  // get additional optional info.\n                  let errorUri = queryParams['error_uri'];\n                  let errorDescription = queryParams['error_description'];\n                  authorizationError = new AuthorizationError({\n                    error: error,\n                    error_description: errorDescription,\n                    error_uri: errorUri,\n                    state: state\n                  });\n                } else {\n                  authorizationResponse = new AuthorizationResponse({code: code, state: state});\n                }\n                // cleanup state\n                return Promise\n                    .all([\n                      this.storageBackend.removeItem(AUTHORIZATION_REQUEST_HANDLE_KEY),\n                      this.storageBackend.removeItem(authorizationRequestKey(handle)),\n                      this.storageBackend.removeItem(authorizationServiceConfigurationKey(handle))\n                    ])\n                    .then(() => {\n                      log('Delivering authorization response');\n                      return {\n                        request: request,\n                        response: authorizationResponse,\n                        error: authorizationError\n                      } as AuthorizationRequestResponse;\n                    });\n              } else {\n                log('Mismatched request (state and request_uri) dont match.');\n                return Promise.resolve(null);\n              }\n            });\n      } else {\n        return null;\n      }\n    });\n  }\n}\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redirect_based_handler.js","sourceRoot":"","sources":["../src/redirect_based_handler.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;;;;;;;;;;;;;;;;AAGH,yFAAuE;AACvE,iEAA6D;AAC7D,iFAA0G;AAC1G,mEAA8D;AAE9D,+CAAqD;AACrD,6DAAwD;AACxD,+DAA0D;AAC1D,mCAA6B;AAC7B,2DAA2D;AAC3D,qCAA8D;AAI9D,IAAK,YAGJ;AAHD,WAAK,YAAY;IACf,0CAA0B,CAAA;IAC1B,+CAA+B,CAAA;AACjC,CAAC,EAHI,YAAY,KAAZ,YAAY,QAGhB;AAED,qCAAqC;AACrC,IAAM,UAAU,GACZ,UAAC,MAAc,EAAE,WAAyB;IACxC,OAAU,MAAM,iBAAY,WAAW,aAAU,CAAC;AACpD,CAAC,CAAA;AAEL,kDAAkD;AAClD,IAAM,uBAAuB,GACzB,UAAC,MAAc,EAAE,WAAyB;IACxC,OAAU,MAAM,iBAAY,WAAW,2BAAwB,CAAC;AAClE,CAAC,CAAA;AAEL,+EAA+E;AAC/E,IAAM,kBAAkB,GAAG,UAAC,WAAyB,IAAK,OAAA,qBAAmB,WAAW,aAAU,EAAxC,CAAwC,CAAC;AAEnG;;;GAGG;AACH;IAA4C,0CAA2B;IACrE;IACI,mCAAmC;IACnC,qEAAqE;IACrE,2BAA2B;IACpB,cAA0D,EACjE,KAAmC,EAC5B,YAA4C,EACnD,MAAoC;QAH7B,+BAAA,EAAA,qBAAqC,6BAAmB,EAAE;QACjE,sBAAA,EAAA,YAAY,0CAAqB,EAAE;QAC5B,6BAAA,EAAA,eAA6B,MAAM,CAAC,QAAQ;QACnD,uBAAA,EAAA,aAAqB,4BAAa,EAAE;QAPxC,YAQE,kBAAM,KAAK,EAAE,MAAM,CAAC,SACrB;QALU,oBAAc,GAAd,cAAc,CAA4C;QAE1D,kBAAY,GAAZ,YAAY,CAAgC;;IAGvD,CAAC;IAED,4DAA2B,GAA3B,UACI,aAAgD,EAChD,OAA6B;QAC/B,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,OAAO,EAAE,YAAY,CAAC,aAAa,CAAC,CAAC;IAC1E,CAAC;IAED,yDAAwB,GAAxB,UACI,aAAgD,EAChD,OAA0B;QAC5B,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,OAAO,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC;IACvE,CAAC;IAEO,+CAAc,GAAtB,UACI,aAAgD,EAChD,OAAuC,EACvC,WAAsD;QAH1D,iBAuBC;QApBG,4BAAA,EAAA,cAA4B,YAAY,CAAC,aAAa;QACxD,IAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;QAE9C,8EAA8E;QAC9E,IAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC;YAC5B,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,kBAAkB,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;YACpE,8DAA8D;YAC9D,OAAO,CAAC,MAAM,EAAE,CAAC,IAAI,CACjB,UAAA,MAAM;gBACF,OAAA,KAAI,CAAC,cAAc,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YAApF,CAAoF,CAAC;YAC7F,IAAI,CAAC,cAAc,CAAC,OAAO,CACvB,uBAAuB,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;SAC1F,CAAC,CAAC;QAEH,SAAS,CAAC,IAAI,CAAC;YACb,4BAA4B;YAC5B,IAAI,GAAG,GAAG,KAAI,CAAC,eAAe,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;YACvD,YAAG,CAAC,sBAAsB,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;YAC1C,KAAI,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAChC,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACO,6DAA4B,GAAtC;QACE,OAAO,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACO,0DAAyB,GAAnC;QACE,OAAO,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;IACvD,CAAC;IAED;;;OAGG;IACK,gDAAe,GAAvB,UAAwB,WAAyB;QAAjD,iBA6EC;QA5EC,gDAAgD;QAChD,OAAO,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,UAAA,MAAM;YAC7E,IAAI,MAAM,EAAE;gBACV,6BAA6B;gBAC7B,+CAA+C;gBAC/C,OAAO,KAAI,CAAC,cAAc;qBACrB,OAAO,CAAC,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;oBACzC,8CAA8C;oBAC9C,qDAAqD;qBACpD,IAAI,CAAC,UAAA,MAAM,IAAI,OAAA,IAAI,CAAC,KAAK,CAAC,MAAO,CAAC,EAAnB,CAAmB,CAAC;qBACnC,IAAI,CACD,UAAA,IAAI,IAAI,OAAA,WAAW,KAAK,YAAY,CAAC,aAAa,CAAC,CAAC;oBAChD,IAAI,4CAAoB,CAAC,IAAI,CAAC,CAAC,CAAC;oBAChC,IAAI,uCAAiB,CAAC,IAAI,CAAC,EAFvB,CAEuB,CAAC;qBACnC,IAAI,CAAC,UAAA,OAAO;oBACX,+BAA+B;oBAC/B,IAAI,UAAU,GAAG,KAAG,KAAI,CAAC,YAAY,CAAC,MAAM,GAAG,KAAI,CAAC,YAAY,CAAC,QAAU,CAAC;oBAC5E,IAAI,WAAW,GAAG,KAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAI,CAAC,YAAY,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;oBAC3E,IAAI,KAAK,GAAqB,WAAW,CAAC,OAAO,CAAC,CAAC;oBACnD,IAAI,IAAI,GAAqB,WAAW,CAAC,MAAM,CAAC,CAAC;oBACjD,IAAI,KAAK,GAAqB,WAAW,CAAC,OAAO,CAAC,CAAC;oBACnD,IAAI,WAAW,KAAK,YAAY,CAAC,aAAa,EAAE;wBAC9C,YAAG,CAAC,kCAAkC,EAClC,UAAU,EACV,WAAW,EACX,KAAK,EACL,IAAI,EACJ,KAAK,CAAC,CAAC;qBACZ;yBAAM;wBACL,YAAG,CAAC,gCAAgC,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,CAAA;qBAC7E;oBACD,IAAI,YAAY,GAAG,KAAK,KAAK,OAAO,CAAC,KAAK,CAAC;oBAC3C,IAAI,qBAAqB,GAAkD,IAAI,CAAC;oBAChF,IAAI,kBAAkB,GAA4B,IAAI,CAAC;oBACvD,IAAI,YAAY,EAAE;wBAChB,IAAI,KAAK,EAAE;4BACT,gCAAgC;4BAChC,IAAI,QAAQ,GAAG,WAAW,CAAC,WAAW,CAAC,CAAC;4BACxC,IAAI,gBAAgB,GAAG,WAAW,CAAC,mBAAmB,CAAC,CAAC;4BACxD,kBAAkB,GAAG,IAAI,sDAAkB,CAAC;gCAC1C,KAAK,EAAE,KAAK;gCACZ,iBAAiB,EAAE,gBAAgB;gCACnC,SAAS,EAAE,QAAQ;gCACnB,KAAK,EAAE,KAAK;6BACb,CAAC,CAAC;yBACJ;6BAAM;4BACL,IAAI,WAAW,KAAK,YAAY,CAAC,aAAa,EAAE;gCAC9C,qBAAqB,GAAG,IAAI,8CAAqB,CAAC,EAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAC,CAAC,CAAC;6BAC/E;iCAAM,IAAI,WAAW,KAAK,YAAY,CAAC,UAAU,EAAE;gCAClD,qBAAqB,GAAG,IAAI,yCAAkB,CAAC,EAAC,KAAK,EAAE,KAAK,EAAC,CAAC,CAAA;6BAC/D;yBACF;wBACD,gBAAgB;wBAChB,OAAO,OAAO;6BACT,GAAG,CAAC;4BACH,KAAI,CAAC,cAAc,CAAC,UAAU,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;4BAC/D,KAAI,CAAC,cAAc,CAAC,UAAU,CAAC,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;4BAC/D,KAAI,CAAC,cAAc,CAAC,UAAU,CAAC,uBAAuB,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;yBAC7E,CAAC;6BACD,IAAI,CAAC;4BACJ,YAAG,CAAC,mCAAmC,CAAC,CAAC;4BACzC,OAAO;gCACL,OAAO,EAAE,OAAO;gCAChB,QAAQ,EAAE,qBAAqB;gCAC/B,KAAK,EAAE,kBAAkB;6BACM,CAAC;wBACpC,CAAC,CAAC,CAAC;qBACR;yBAAM;wBACL,YAAG,CAAC,wDAAwD,CAAC,CAAC;wBAC9D,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;qBAC9B;gBACH,CAAC,CAAC,CAAC;aACR;iBAAM;gBACL,OAAO,IAAI,CAAC;aACb;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IACH,6BAAC;AAAD,CAAC,AAnJD,CAA4C,2DAA2B,GAmJtE;AAnJY,wDAAsB","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {AuthorizationManagementRequest} from './authorization_management_request';\nimport {AuthorizationError} from './authorization_management_response';\nimport {AuthorizationRequest} from './authorization_request';\nimport {AuthorizationRequestHandler, AuthorizationRequestResponse} from './authorization_request_handler';\nimport {AuthorizationResponse} from './authorization_response'\nimport {AuthorizationServiceConfiguration} from './authorization_service_configuration';\nimport {Crypto, DefaultCrypto} from './crypto_utils';\nimport {EndSessionRequest} from './end_session_request';\nimport {EndSessionResponse} from './end_session_response';\nimport {log} from './logger';\nimport {BasicQueryStringUtils} from './query_string_utils';\nimport {LocalStorageBackend, StorageBackend} from './storage';\nimport {LocationLike} from './types';\n\n\nenum RequestTypes {\n  endSession = 'end_session',\n  authorization = 'authorization'\n}\n\n/** key for authorization request. */\nconst requestKey =\n    (handle: string, requestType: RequestTypes) => {\n      return `${handle}_appauth_${requestType}_request`;\n    }\n\n/** key for authorization service configuration */\nconst serviceConfigurationKey =\n    (handle: string, requestType: RequestTypes) => {\n      return `${handle}_appauth_${requestType}_service_configuration`;\n    }\n\n/** key in local storage which represents the current authorization request. */\nconst REQUEST_HANDLE_KEY = (requestType: RequestTypes) => `appauth_current_${requestType}_request`;\n\n/**\n * Represents an AuthorizationRequestHandler which uses a standard\n * redirect based code flow.\n */\nexport class RedirectRequestHandler extends AuthorizationRequestHandler {\n  constructor(\n      // use the provided storage backend\n      // or initialize local storage with the default storage backend which\n      // uses window.localStorage\n      public storageBackend: StorageBackend = new LocalStorageBackend(),\n      utils = new BasicQueryStringUtils(),\n      public locationLike: LocationLike = window.location,\n      crypto: Crypto = new DefaultCrypto()) {\n    super(utils, crypto);\n  }\n\n  performAuthorizationRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationRequest) {\n    this.performRequest(configuration, request, RequestTypes.authorization);\n  }\n\n  performEndSessionRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: EndSessionRequest) {\n    this.performRequest(configuration, request, RequestTypes.endSession);\n  }\n\n  private performRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationManagementRequest,\n      requestType: RequestTypes = RequestTypes.authorization) {\n    const handle = this.crypto.generateRandom(10);\n\n    // before you make request, persist all request related data in local storage.\n    const persisted = Promise.all([\n      this.storageBackend.setItem(REQUEST_HANDLE_KEY(requestType), handle),\n      // Calling toJson() adds in the code & challenge when possible\n      request.toJson().then(\n          result =>\n              this.storageBackend.setItem(requestKey(handle, requestType), JSON.stringify(result))),\n      this.storageBackend.setItem(\n          serviceConfigurationKey(handle, requestType), JSON.stringify(configuration.toJson())),\n    ]);\n\n    persisted.then(() => {\n      // make the redirect request\n      let url = this.buildRequestUrl(configuration, request);\n      log('Making a request to ', request, url);\n      this.locationLike.assign(url);\n    });\n  }\n\n  /**\n   * Attempts to introspect the contents of storage backend and completes the\n   *  authorization request.\n   */\n  protected completeAuthorizationRequest(): Promise<AuthorizationRequestResponse|null> {\n    return this.completeRequest(RequestTypes.authorization);\n  }\n\n  /**\n   * Attempts to introspect the contents of storage backend and completes the\n   * end session request.\n   */\n  protected completeEndSessionRequest(): Promise<AuthorizationRequestResponse|null> {\n    return this.completeRequest(RequestTypes.endSession);\n  }\n\n  /**\n   * Attempts to introspect the contents of storage backend and completes the\n   * request.\n   */\n  private completeRequest(requestType: RequestTypes) {\n    // TODO(rahulrav@): handle authorization errors.\n    return this.storageBackend.getItem(REQUEST_HANDLE_KEY(requestType)).then(handle => {\n      if (handle) {\n        // we have a pending request.\n        // fetch authorization request, and check state\n        return this.storageBackend\n            .getItem(requestKey(handle, requestType))\n            // requires a corresponding instance of result\n            // TODO(rahulrav@): check for inconsistent state here\n            .then(result => JSON.parse(result!))\n            .then(\n                json => requestType === RequestTypes.authorization ?\n                    new AuthorizationRequest(json) :\n                    new EndSessionRequest(json))\n            .then(request => {\n              // check redirect_uri and state\n              let currentUri = `${this.locationLike.origin}${this.locationLike.pathname}`;\n              let queryParams = this.utils.parse(this.locationLike, true /* use hash */);\n              let state: string|undefined = queryParams['state'];\n              let code: string|undefined = queryParams['code'];\n              let error: string|undefined = queryParams['error'];\n              if (requestType === RequestTypes.authorization) {\n                log('Potential authorization request ',\n                    currentUri,\n                    queryParams,\n                    state,\n                    code,\n                    error);\n              } else {\n                log('Potential end session request ', currentUri, queryParams, state, error)\n              }\n              let shouldNotify = state === request.state;\n              let authorizationResponse: EndSessionResponse|AuthorizationResponse|null = null;\n              let authorizationError: AuthorizationError|null = null;\n              if (shouldNotify) {\n                if (error) {\n                  // get additional optional info.\n                  let errorUri = queryParams['error_uri'];\n                  let errorDescription = queryParams['error_description'];\n                  authorizationError = new AuthorizationError({\n                    error: error,\n                    error_description: errorDescription,\n                    error_uri: errorUri,\n                    state: state\n                  });\n                } else {\n                  if (requestType === RequestTypes.authorization) {\n                    authorizationResponse = new AuthorizationResponse({code: code, state: state});\n                  } else if (requestType === RequestTypes.endSession) {\n                    authorizationResponse = new EndSessionResponse({state: state})\n                  }\n                }\n                // cleanup state\n                return Promise\n                    .all([\n                      this.storageBackend.removeItem(REQUEST_HANDLE_KEY(requestType)),\n                      this.storageBackend.removeItem(requestKey(handle, requestType)),\n                      this.storageBackend.removeItem(serviceConfigurationKey(handle, requestType))\n                    ])\n                    .then(() => {\n                      log('Delivering authorization response');\n                      return {\n                        request: request,\n                        response: authorizationResponse,\n                        error: authorizationError\n                      } as AuthorizationRequestResponse;\n                    });\n              } else {\n                log('Mismatched request (state and request_uri) dont match.');\n                return Promise.resolve(null);\n              }\n            });\n      } else {\n        return null;\n      }\n    });\n  }\n}\n"]} \ No newline at end of file diff --git a/src/app/index.ts b/src/app/index.ts index 3060ddb..d2705ac 100644 --- a/src/app/index.ts +++ b/src/app/index.ts @@ -24,6 +24,7 @@ import {BaseTokenRequestHandler, TokenRequestHandler} from '../token_request_han import {TokenResponse} from '../token_response'; import { AuthorizationResponse } from '../authorization_response'; import { StringMap } from '../types'; +import { EndSessionRequest } from '../end_session_request'; /* Some interface declarations for Material design lite. */ diff --git a/src/end_session_redirect_based_handler.ts b/src/end_session_redirect_based_handler.ts deleted file mode 100644 index 8fbec64..0000000 --- a/src/end_session_redirect_based_handler.ts +++ /dev/null @@ -1,145 +0,0 @@ -/* - * Copyright 2017 Google Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except - * in compliance with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the - * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either - * express or implied. See the License for the specific language governing permissions and - * limitations under the License. - */ - -import {AuthorizationError} from './authorization_management_response'; -import {AuthorizationRequestHandler, AuthorizationRequestResponse} from './authorization_request_handler'; -import {AuthorizationServiceConfiguration} from './authorization_service_configuration'; -import {Crypto, DefaultCrypto} from './crypto_utils'; -import {EndSessionRequest} from './end_session_request'; -import {EndSessionResponse} from './end_session_response' -import {log} from './logger'; -import {BasicQueryStringUtils} from './query_string_utils'; -import {LocalStorageBackend, StorageBackend} from './storage'; -import {LocationLike} from './types'; - - -/** key for endsession request. */ -const endSessionRequestKey = - (handle: string) => { - return `${handle}_appauth_endsession_request`; - } - -/** key for authorization service configuration */ -const authorizationServiceConfigurationKey = - (handle: string) => { - return `${handle}_appauth_authorization_service_configuration`; - } - -/** key in local storage which represents the current endsession request. */ -const ENDSESSION_REQUEST_HANDLE_KEY = 'appauth_current_endsession_request'; - -/** - * Represents an EndSessionRequestHandler which uses a standard - * redirect based code flow. - */ -export class EndSessionRedirectRequestHandler extends AuthorizationRequestHandler { - constructor( - // use the provided storage backend - // or initialize local storage with the default storage backend which - // uses window.localStorage - public storageBackend: StorageBackend = new LocalStorageBackend(), - utils = new BasicQueryStringUtils(), - public locationLike: LocationLike = window.location, - crypto: Crypto = new DefaultCrypto()) { - super(utils, crypto); - } - - performAuthorizationRequest( - configuration: AuthorizationServiceConfiguration, - request: EndSessionRequest) { - const handle = this.crypto.generateRandom(10); - // before you make request, persist all request related data in local storage. - let persisted = Promise.all([ - this.storageBackend.setItem(ENDSESSION_REQUEST_HANDLE_KEY, handle), - request.toJson().then( - result => - this.storageBackend.setItem(endSessionRequestKey(handle), JSON.stringify(result))), - this.storageBackend.setItem( - authorizationServiceConfigurationKey(handle), JSON.stringify(configuration.toJson())), - ]); - - persisted.then(() => { - // make the redirect request - let url = this.buildRequestUrl(configuration, request); - log('Making a request to ', request, url); - this.locationLike.assign(url); - }); - } - - /** - * Attempts to introspect the contents of storage backend and completes the - * request. - */ - protected completeAuthorizationRequest(): Promise { - // TODO(rahulrav@): handle endsession errors. - return this.storageBackend.getItem(ENDSESSION_REQUEST_HANDLE_KEY).then(handle => { - if (handle) { - // we have a pending request. - // fetch endsession request, and check state - return this.storageBackend - .getItem(endSessionRequestKey(handle)) - // requires a corresponding instance of result - // TODO(rahulrav@): check for inconsitent state here - .then(result => JSON.parse(result!)) - .then(json => new EndSessionRequest(json)) - .then(request => { - // check redirect_uri and state - let currentUri = `${this.locationLike.origin}${this.locationLike.pathname}`; - let queryParams = this.utils.parse(this.locationLike, true /* use hash */); - let state: string|undefined = queryParams['state']; - let error: string|undefined = queryParams['error']; - log('Potential endsession request ', currentUri, queryParams, state, error); - let shouldNotify = state === request.state; - let endSessionResponse: EndSessionResponse|null = null; - let endSessionError: AuthorizationError|null = null; - if (shouldNotify) { - if (error) { - // get additional optional info. - let errorUri = queryParams['error_uri']; - let errorDescription = queryParams['error_description']; - endSessionError = new AuthorizationError({ - error: error, - error_description: errorDescription, - error_uri: errorUri, - state: state - }); - } else { - endSessionResponse = new EndSessionResponse({state: state}); - } - // cleanup state - return Promise - .all([ - this.storageBackend.removeItem(ENDSESSION_REQUEST_HANDLE_KEY), - this.storageBackend.removeItem(endSessionRequestKey(handle)), - this.storageBackend.removeItem(authorizationServiceConfigurationKey(handle)) - ]) - .then(() => { - log('Delivering endsession response'); - return { - request: request, - response: endSessionResponse, - error: endSessionError - } as AuthorizationRequestResponse; - }); - } else { - log('Mismatched request (state and request_uri) dont match.'); - return Promise.resolve(null); - } - }); - } else { - return null; - } - }); - } -} \ No newline at end of file diff --git a/src/redirect_based_handler.ts b/src/redirect_based_handler.ts index 514248e..d96cc2c 100644 --- a/src/redirect_based_handler.ts +++ b/src/redirect_based_handler.ts @@ -12,32 +12,40 @@ * limitations under the License. */ +import {AuthorizationManagementRequest} from './authorization_management_request'; import {AuthorizationError} from './authorization_management_response'; import {AuthorizationRequest} from './authorization_request'; import {AuthorizationRequestHandler, AuthorizationRequestResponse} from './authorization_request_handler'; import {AuthorizationResponse} from './authorization_response' import {AuthorizationServiceConfiguration} from './authorization_service_configuration'; import {Crypto, DefaultCrypto} from './crypto_utils'; +import {EndSessionRequest} from './end_session_request'; +import {EndSessionResponse} from './end_session_response'; import {log} from './logger'; import {BasicQueryStringUtils} from './query_string_utils'; import {LocalStorageBackend, StorageBackend} from './storage'; import {LocationLike} from './types'; +enum RequestTypes { + endSession = 'end_session', + authorization = 'authorization' +} + /** key for authorization request. */ -const authorizationRequestKey = - (handle: string) => { - return `${handle}_appauth_authorization_request`; +const requestKey = + (handle: string, requestType: RequestTypes) => { + return `${handle}_appauth_${requestType}_request`; } /** key for authorization service configuration */ -const authorizationServiceConfigurationKey = - (handle: string) => { - return `${handle}_appauth_authorization_service_configuration`; +const serviceConfigurationKey = + (handle: string, requestType: RequestTypes) => { + return `${handle}_appauth_${requestType}_service_configuration`; } /** key in local storage which represents the current authorization request. */ -const AUTHORIZATION_REQUEST_HANDLE_KEY = 'appauth_current_authorization_request'; +const REQUEST_HANDLE_KEY = (requestType: RequestTypes) => `appauth_current_${requestType}_request`; /** * Represents an AuthorizationRequestHandler which uses a standard @@ -58,17 +66,30 @@ export class RedirectRequestHandler extends AuthorizationRequestHandler { performAuthorizationRequest( configuration: AuthorizationServiceConfiguration, request: AuthorizationRequest) { + this.performRequest(configuration, request, RequestTypes.authorization); + } + + performEndSessionRequest( + configuration: AuthorizationServiceConfiguration, + request: EndSessionRequest) { + this.performRequest(configuration, request, RequestTypes.endSession); + } + + private performRequest( + configuration: AuthorizationServiceConfiguration, + request: AuthorizationManagementRequest, + requestType: RequestTypes = RequestTypes.authorization) { const handle = this.crypto.generateRandom(10); // before you make request, persist all request related data in local storage. const persisted = Promise.all([ - this.storageBackend.setItem(AUTHORIZATION_REQUEST_HANDLE_KEY, handle), + this.storageBackend.setItem(REQUEST_HANDLE_KEY(requestType), handle), // Calling toJson() adds in the code & challenge when possible request.toJson().then( result => - this.storageBackend.setItem(authorizationRequestKey(handle), JSON.stringify(result))), + this.storageBackend.setItem(requestKey(handle, requestType), JSON.stringify(result))), this.storageBackend.setItem( - authorizationServiceConfigurationKey(handle), JSON.stringify(configuration.toJson())), + serviceConfigurationKey(handle, requestType), JSON.stringify(configuration.toJson())), ]); persisted.then(() => { @@ -81,20 +102,39 @@ export class RedirectRequestHandler extends AuthorizationRequestHandler { /** * Attempts to introspect the contents of storage backend and completes the - * request. + * authorization request. */ protected completeAuthorizationRequest(): Promise { + return this.completeRequest(RequestTypes.authorization); + } + + /** + * Attempts to introspect the contents of storage backend and completes the + * end session request. + */ + protected completeEndSessionRequest(): Promise { + return this.completeRequest(RequestTypes.endSession); + } + + /** + * Attempts to introspect the contents of storage backend and completes the + * request. + */ + private completeRequest(requestType: RequestTypes) { // TODO(rahulrav@): handle authorization errors. - return this.storageBackend.getItem(AUTHORIZATION_REQUEST_HANDLE_KEY).then(handle => { + return this.storageBackend.getItem(REQUEST_HANDLE_KEY(requestType)).then(handle => { if (handle) { // we have a pending request. // fetch authorization request, and check state return this.storageBackend - .getItem(authorizationRequestKey(handle)) + .getItem(requestKey(handle, requestType)) // requires a corresponding instance of result - // TODO(rahulrav@): check for inconsitent state here + // TODO(rahulrav@): check for inconsistent state here .then(result => JSON.parse(result!)) - .then(json => new AuthorizationRequest(json)) + .then( + json => requestType === RequestTypes.authorization ? + new AuthorizationRequest(json) : + new EndSessionRequest(json)) .then(request => { // check redirect_uri and state let currentUri = `${this.locationLike.origin}${this.locationLike.pathname}`; @@ -102,9 +142,18 @@ export class RedirectRequestHandler extends AuthorizationRequestHandler { let state: string|undefined = queryParams['state']; let code: string|undefined = queryParams['code']; let error: string|undefined = queryParams['error']; - log('Potential authorization request ', currentUri, queryParams, state, code, error); + if (requestType === RequestTypes.authorization) { + log('Potential authorization request ', + currentUri, + queryParams, + state, + code, + error); + } else { + log('Potential end session request ', currentUri, queryParams, state, error) + } let shouldNotify = state === request.state; - let authorizationResponse: AuthorizationResponse|null = null; + let authorizationResponse: EndSessionResponse|AuthorizationResponse|null = null; let authorizationError: AuthorizationError|null = null; if (shouldNotify) { if (error) { @@ -118,14 +167,18 @@ export class RedirectRequestHandler extends AuthorizationRequestHandler { state: state }); } else { - authorizationResponse = new AuthorizationResponse({code: code, state: state}); + if (requestType === RequestTypes.authorization) { + authorizationResponse = new AuthorizationResponse({code: code, state: state}); + } else if (requestType === RequestTypes.endSession) { + authorizationResponse = new EndSessionResponse({state: state}) + } } // cleanup state return Promise .all([ - this.storageBackend.removeItem(AUTHORIZATION_REQUEST_HANDLE_KEY), - this.storageBackend.removeItem(authorizationRequestKey(handle)), - this.storageBackend.removeItem(authorizationServiceConfigurationKey(handle)) + this.storageBackend.removeItem(REQUEST_HANDLE_KEY(requestType)), + this.storageBackend.removeItem(requestKey(handle, requestType)), + this.storageBackend.removeItem(serviceConfigurationKey(handle, requestType)) ]) .then(() => { log('Delivering authorization response'); From 28183eb0a27da57e5bca3350ec0f7e0f0e40d98a Mon Sep 17 00:00:00 2001 From: Arsalan Salari Date: Thu, 9 Sep 2021 11:44:33 +0430 Subject: [PATCH 08/13] Add new files to index --- built/index.d.ts | 4 ++++ built/index.js | 6 +++++- src/index.ts | 4 ++++ 3 files changed, 13 insertions(+), 1 deletion(-) diff --git a/built/index.d.ts b/built/index.d.ts index d49785b..fc734ad 100644 --- a/built/index.d.ts +++ b/built/index.d.ts @@ -15,3 +15,7 @@ export * from './token_request_handler'; export * from './token_response'; export * from './types'; export * from './xhr'; +export * from './authorization_management_request'; +export * from './end_session_request'; +export * from './end_session_response'; +export * from './authorization_management_response'; diff --git a/built/index.js b/built/index.js index e516565..e22b591 100644 --- a/built/index.js +++ b/built/index.js @@ -27,4 +27,8 @@ __exportStar(require("./token_request_handler"), exports); __exportStar(require("./token_response"), exports); __exportStar(require("./types"), exports); __exportStar(require("./xhr"), exports); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEsMERBQXdDO0FBQ3hDLGtFQUFnRDtBQUNoRCwyREFBeUM7QUFDekMsd0VBQXNEO0FBQ3RELGlEQUErQjtBQUMvQiwyQ0FBeUI7QUFDekIsMENBQXdCO0FBQ3hCLDJDQUF5QjtBQUN6Qix1REFBcUM7QUFDckMsMkRBQXlDO0FBQ3pDLHlEQUF1QztBQUN2Qyw0Q0FBMEI7QUFDMUIsa0RBQWdDO0FBQ2hDLDBEQUF3QztBQUN4QyxtREFBaUM7QUFDakMsMENBQXdCO0FBQ3hCLHdDQUFzQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXV0aG9yaXphdGlvbl9yZXF1ZXN0JztcbmV4cG9ydCAqIGZyb20gJy4vYXV0aG9yaXphdGlvbl9yZXF1ZXN0X2hhbmRsZXInO1xuZXhwb3J0ICogZnJvbSAnLi9hdXRob3JpemF0aW9uX3Jlc3BvbnNlJztcbmV4cG9ydCAqIGZyb20gJy4vYXV0aG9yaXphdGlvbl9zZXJ2aWNlX2NvbmZpZ3VyYXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9jcnlwdG9fdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9lcnJvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9mbGFncyc7XG5leHBvcnQgKiBmcm9tICcuL2xvZ2dlcic7XG5leHBvcnQgKiBmcm9tICcuL3F1ZXJ5X3N0cmluZ191dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL3JlZGlyZWN0X2Jhc2VkX2hhbmRsZXInO1xuZXhwb3J0ICogZnJvbSAnLi9yZXZva2VfdG9rZW5fcmVxdWVzdCc7XG5leHBvcnQgKiBmcm9tICcuL3N0b3JhZ2UnO1xuZXhwb3J0ICogZnJvbSAnLi90b2tlbl9yZXF1ZXN0JztcbmV4cG9ydCAqIGZyb20gJy4vdG9rZW5fcmVxdWVzdF9oYW5kbGVyJztcbmV4cG9ydCAqIGZyb20gJy4vdG9rZW5fcmVzcG9uc2UnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL3hocic7XG4iXX0= \ No newline at end of file +__exportStar(require("./authorization_management_request"), exports); +__exportStar(require("./end_session_request"), exports); +__exportStar(require("./end_session_response"), exports); +__exportStar(require("./authorization_management_response"), exports); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEsMERBQXdDO0FBQ3hDLGtFQUFnRDtBQUNoRCwyREFBeUM7QUFDekMsd0VBQXNEO0FBQ3RELGlEQUErQjtBQUMvQiwyQ0FBeUI7QUFDekIsMENBQXdCO0FBQ3hCLDJDQUF5QjtBQUN6Qix1REFBcUM7QUFDckMsMkRBQXlDO0FBQ3pDLHlEQUF1QztBQUN2Qyw0Q0FBMEI7QUFDMUIsa0RBQWdDO0FBQ2hDLDBEQUF3QztBQUN4QyxtREFBaUM7QUFDakMsMENBQXdCO0FBQ3hCLHdDQUFzQjtBQUN0QixxRUFBbUQ7QUFDbkQsd0RBQXNDO0FBQ3RDLHlEQUF1QztBQUN2QyxzRUFBb0QiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2F1dGhvcml6YXRpb25fcmVxdWVzdCc7XG5leHBvcnQgKiBmcm9tICcuL2F1dGhvcml6YXRpb25fcmVxdWVzdF9oYW5kbGVyJztcbmV4cG9ydCAqIGZyb20gJy4vYXV0aG9yaXphdGlvbl9yZXNwb25zZSc7XG5leHBvcnQgKiBmcm9tICcuL2F1dGhvcml6YXRpb25fc2VydmljZV9jb25maWd1cmF0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vY3J5cHRvX3V0aWxzJztcbmV4cG9ydCAqIGZyb20gJy4vZXJyb3JzJztcbmV4cG9ydCAqIGZyb20gJy4vZmxhZ3MnO1xuZXhwb3J0ICogZnJvbSAnLi9sb2dnZXInO1xuZXhwb3J0ICogZnJvbSAnLi9xdWVyeV9zdHJpbmdfdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9yZWRpcmVjdF9iYXNlZF9oYW5kbGVyJztcbmV4cG9ydCAqIGZyb20gJy4vcmV2b2tlX3Rva2VuX3JlcXVlc3QnO1xuZXhwb3J0ICogZnJvbSAnLi9zdG9yYWdlJztcbmV4cG9ydCAqIGZyb20gJy4vdG9rZW5fcmVxdWVzdCc7XG5leHBvcnQgKiBmcm9tICcuL3Rva2VuX3JlcXVlc3RfaGFuZGxlcic7XG5leHBvcnQgKiBmcm9tICcuL3Rva2VuX3Jlc3BvbnNlJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi94aHInO1xuZXhwb3J0ICogZnJvbSAnLi9hdXRob3JpemF0aW9uX21hbmFnZW1lbnRfcmVxdWVzdCc7XG5leHBvcnQgKiBmcm9tICcuL2VuZF9zZXNzaW9uX3JlcXVlc3QnO1xuZXhwb3J0ICogZnJvbSAnLi9lbmRfc2Vzc2lvbl9yZXNwb25zZSc7XG5leHBvcnQgKiBmcm9tICcuL2F1dGhvcml6YXRpb25fbWFuYWdlbWVudF9yZXNwb25zZSc7Il19 \ No newline at end of file diff --git a/src/index.ts b/src/index.ts index d49785b..04552b5 100644 --- a/src/index.ts +++ b/src/index.ts @@ -15,3 +15,7 @@ export * from './token_request_handler'; export * from './token_response'; export * from './types'; export * from './xhr'; +export * from './authorization_management_request'; +export * from './end_session_request'; +export * from './end_session_response'; +export * from './authorization_management_response'; \ No newline at end of file From 8772621826b0779bab3074d111025f9a19204153 Mon Sep 17 00:00:00 2001 From: Arsalan Salari Date: Sat, 11 Sep 2021 18:58:59 +0430 Subject: [PATCH 09/13] Add end session end points to auth handler --- src/authorization_request_handler.ts | 43 ++++++++++++++++++++++++++-- src/types.ts | 5 ++++ 2 files changed, 45 insertions(+), 3 deletions(-) diff --git a/src/authorization_request_handler.ts b/src/authorization_request_handler.ts index a299ba1..66d6a4d 100644 --- a/src/authorization_request_handler.ts +++ b/src/authorization_request_handler.ts @@ -19,7 +19,7 @@ import {AuthorizationServiceConfiguration} from './authorization_service_configu import {Crypto} from './crypto_utils'; import {log} from './logger'; import {QueryStringUtils} from './query_string_utils'; -import {StringMap} from './types'; +import {RedirectRequestTypes, StringMap} from './types'; /** @@ -81,12 +81,15 @@ export abstract class AuthorizationRequestHandler { */ protected buildRequestUrl( configuration: AuthorizationServiceConfiguration, - request: AuthorizationManagementRequest) { + request: AuthorizationManagementRequest, + requestType: RedirectRequestTypes) { // build the query string // coerce to any type for convenience let requestMap: StringMap = request.toRequestMap() let query = this.utils.stringify(requestMap); - let baseUrl = configuration.authorizationEndpoint; + let baseUrl = requestType === RedirectRequestTypes.authorization ? + configuration.authorizationEndpoint : + configuration.endSessionEndpoint; let url = `${baseUrl}?${query}`; return url; } @@ -112,6 +115,27 @@ export abstract class AuthorizationRequestHandler { }); } + /** + * Completes the endsession request if necessary & when possible. + */ + completeEndSessionRequestIfPossible(): Promise { + // call complete endsession if possible to see there might + // be a response that needs to be delivered. + log(`Checking to see if there is an endsession response to be delivered.`); + if (!this.notifier) { + log(`Notifier is not present on EndSessionRequest handler. + No delivery of result will be possible`) + } + return this.completeEndSessionRequest().then(result => { + if (!result) { + log(`No result is available yet.`); + } + if (result && this.notifier) { + this.notifier.onAuthorizationComplete(result.request, result.response, result.error); + } + }); + } + /** * Sets the default Authorization Service notifier. */ @@ -127,10 +151,23 @@ export abstract class AuthorizationRequestHandler { configuration: AuthorizationServiceConfiguration, request: AuthorizationManagementRequest): void; + /** + * Makes an end session request. + */ + abstract performEndSessionRequest( + configuration: AuthorizationServiceConfiguration, + request: AuthorizationManagementRequest): void; /** * Checks if an authorization flow can be completed, and completes it. * The handler returns a `Promise` if ready, or a `Promise` * if not ready. */ protected abstract completeAuthorizationRequest(): Promise; + + /** + * Checks if an end session flow can be completed, and completes it. + * The handler returns a `Promise` if ready, or a `Promise` + * if not ready. + */ + protected abstract completeEndSessionRequest(): Promise; } diff --git a/src/types.ts b/src/types.ts index 3af235a..280830b 100644 --- a/src/types.ts +++ b/src/types.ts @@ -30,3 +30,8 @@ export interface LocationLike { search: string; assign(url: string): void; } + +export enum RedirectRequestTypes { + endSession = 'end_session', + authorization = 'authorization' +} \ No newline at end of file From a1cf53de469c878429aa061539f8519f71a90654 Mon Sep 17 00:00:00 2001 From: Arsalan Salari Date: Sat, 11 Sep 2021 18:59:22 +0430 Subject: [PATCH 10/13] Fix node related files --- src/node_support/node_request_handler.ts | 50 +++++++++++++++++++----- src/redirect_based_handler.ts | 36 ++++++++--------- 2 files changed, 57 insertions(+), 29 deletions(-) diff --git a/src/node_support/node_request_handler.ts b/src/node_support/node_request_handler.ts index d6ff270..ae339ac 100644 --- a/src/node_support/node_request_handler.ts +++ b/src/node_support/node_request_handler.ts @@ -15,7 +15,7 @@ import {EventEmitter} from 'events'; import * as Http from 'http'; import * as Url from 'url'; -import {AuthorizationRequest} from '../authorization_request'; +import {AuthorizationManagementRequest} from '../authorization_management_request'; import {AuthorizationRequestHandler, AuthorizationRequestResponse} from '../authorization_request_handler'; import {AuthorizationResponse} from '../authorization_response'; import {AuthorizationError} from '../authorization_management_response'; @@ -24,10 +24,13 @@ import {Crypto} from '../crypto_utils'; import {log} from '../logger'; import {BasicQueryStringUtils, QueryStringUtils} from '../query_string_utils'; import {NodeCrypto} from './crypto_utils'; +import {RedirectRequestTypes} from '../types'; +import {EndSessionResponse} from '../end_session_response'; // TypeScript typings for `opener` are not correct and do not export it as module import opener = require('opener'); +import { AuthorizationRequest } from '../authorization_request'; class ServerEventsEmitter extends EventEmitter { static ON_UNABLE_TO_START = 'unable_to_start'; @@ -46,9 +49,18 @@ export class NodeBasedHandler extends AuthorizationRequestHandler { super(utils, crypto); } - performAuthorizationRequest( + performAuthorizationRequest(configuration: AuthorizationServiceConfiguration, request: AuthorizationRequest){ + this.performRequest(configuration, request, RedirectRequestTypes.authorization); + } + + performEndSessionRequest(configuration: AuthorizationServiceConfiguration, request: AuthorizationRequest){ + this.performRequest(configuration, request, RedirectRequestTypes.endSession); + } + + private performRequest( configuration: AuthorizationServiceConfiguration, - request: AuthorizationRequest) { + request: AuthorizationManagementRequest, + requestType: RedirectRequestTypes) { // use opener to launch a web browser and start the authorization flow. // start a web server to handle the authorization response. const emitter = new ServerEventsEmitter(); @@ -70,8 +82,12 @@ export class NodeBasedHandler extends AuthorizationRequestHandler { return; } - log('Handling Authorization Request ', searchParams, state, code, error); - let authorizationResponse: AuthorizationResponse|null = null; + if(requestType === RedirectRequestTypes.authorization){ + log('Handling Authorization Request ', searchParams, state, code, error); + } else if(requestType === RedirectRequestTypes.endSession){ + log('Handling end session Request ', searchParams, state, error); + } + let authorizationResponse: EndSessionResponse|AuthorizationResponse|null = null; let authorizationError: AuthorizationError|null = null; if (error) { log('error'); @@ -81,7 +97,11 @@ export class NodeBasedHandler extends AuthorizationRequestHandler { authorizationError = new AuthorizationError( {error: error, error_description: errorDescription, error_uri: errorUri, state: state}); } else { - authorizationResponse = new AuthorizationResponse({code: code!, state: state!}); + if (requestType === RedirectRequestTypes.authorization) { + authorizationResponse = new AuthorizationResponse({code: code!, state: state!}); + } else if (requestType === RedirectRequestTypes.endSession) { + authorizationResponse = new EndSessionResponse({state: state!}) + } } const completeResponse = { request, @@ -106,11 +126,15 @@ export class NodeBasedHandler extends AuthorizationRequestHandler { }); let server: Http.Server; - request.setupCodeVerifier() - .then(() => { + let codeVerified: Promise = Promise.resolve(); + if(request instanceof AuthorizationRequest){ + codeVerified = request.setupCodeVerifier() + } + + codeVerified.then(() => { server = Http.createServer(requestHandler); server.listen(this.httpServerPort); - const url = this.buildRequestUrl(configuration, request); + const url = this.buildRequestUrl(configuration, request, requestType); log('Making a request to ', request, url); opener(url); }) @@ -121,6 +145,14 @@ export class NodeBasedHandler extends AuthorizationRequestHandler { } protected completeAuthorizationRequest(): Promise { + return this.completeRequest(); + } + + protected completeEndSessionRequest(): Promise { + return this.completeRequest(); + } + + private completeRequest(): Promise { if (!this.authorizationPromise) { return Promise.reject( 'No pending authorization request. Call performAuthorizationRequest() ?'); diff --git a/src/redirect_based_handler.ts b/src/redirect_based_handler.ts index d96cc2c..c435f3e 100644 --- a/src/redirect_based_handler.ts +++ b/src/redirect_based_handler.ts @@ -24,28 +24,24 @@ import {EndSessionResponse} from './end_session_response'; import {log} from './logger'; import {BasicQueryStringUtils} from './query_string_utils'; import {LocalStorageBackend, StorageBackend} from './storage'; -import {LocationLike} from './types'; +import {LocationLike, RedirectRequestTypes} from './types'; -enum RequestTypes { - endSession = 'end_session', - authorization = 'authorization' -} - /** key for authorization request. */ const requestKey = - (handle: string, requestType: RequestTypes) => { + (handle: string, requestType: RedirectRequestTypes) => { return `${handle}_appauth_${requestType}_request`; } /** key for authorization service configuration */ const serviceConfigurationKey = - (handle: string, requestType: RequestTypes) => { + (handle: string, requestType: RedirectRequestTypes) => { return `${handle}_appauth_${requestType}_service_configuration`; } /** key in local storage which represents the current authorization request. */ -const REQUEST_HANDLE_KEY = (requestType: RequestTypes) => `appauth_current_${requestType}_request`; +const REQUEST_HANDLE_KEY = (requestType: RedirectRequestTypes) => + `appauth_current_${requestType}_request`; /** * Represents an AuthorizationRequestHandler which uses a standard @@ -66,19 +62,19 @@ export class RedirectRequestHandler extends AuthorizationRequestHandler { performAuthorizationRequest( configuration: AuthorizationServiceConfiguration, request: AuthorizationRequest) { - this.performRequest(configuration, request, RequestTypes.authorization); + this.performRequest(configuration, request, RedirectRequestTypes.authorization); } performEndSessionRequest( configuration: AuthorizationServiceConfiguration, request: EndSessionRequest) { - this.performRequest(configuration, request, RequestTypes.endSession); + this.performRequest(configuration, request, RedirectRequestTypes.endSession); } private performRequest( configuration: AuthorizationServiceConfiguration, request: AuthorizationManagementRequest, - requestType: RequestTypes = RequestTypes.authorization) { + requestType: RedirectRequestTypes = RedirectRequestTypes.authorization) { const handle = this.crypto.generateRandom(10); // before you make request, persist all request related data in local storage. @@ -94,7 +90,7 @@ export class RedirectRequestHandler extends AuthorizationRequestHandler { persisted.then(() => { // make the redirect request - let url = this.buildRequestUrl(configuration, request); + let url = this.buildRequestUrl(configuration, request, requestType); log('Making a request to ', request, url); this.locationLike.assign(url); }); @@ -105,7 +101,7 @@ export class RedirectRequestHandler extends AuthorizationRequestHandler { * authorization request. */ protected completeAuthorizationRequest(): Promise { - return this.completeRequest(RequestTypes.authorization); + return this.completeRequest(RedirectRequestTypes.authorization); } /** @@ -113,14 +109,14 @@ export class RedirectRequestHandler extends AuthorizationRequestHandler { * end session request. */ protected completeEndSessionRequest(): Promise { - return this.completeRequest(RequestTypes.endSession); + return this.completeRequest(RedirectRequestTypes.endSession); } /** * Attempts to introspect the contents of storage backend and completes the * request. */ - private completeRequest(requestType: RequestTypes) { + private completeRequest(requestType: RedirectRequestTypes) { // TODO(rahulrav@): handle authorization errors. return this.storageBackend.getItem(REQUEST_HANDLE_KEY(requestType)).then(handle => { if (handle) { @@ -132,7 +128,7 @@ export class RedirectRequestHandler extends AuthorizationRequestHandler { // TODO(rahulrav@): check for inconsistent state here .then(result => JSON.parse(result!)) .then( - json => requestType === RequestTypes.authorization ? + json => requestType === RedirectRequestTypes.authorization ? new AuthorizationRequest(json) : new EndSessionRequest(json)) .then(request => { @@ -142,7 +138,7 @@ export class RedirectRequestHandler extends AuthorizationRequestHandler { let state: string|undefined = queryParams['state']; let code: string|undefined = queryParams['code']; let error: string|undefined = queryParams['error']; - if (requestType === RequestTypes.authorization) { + if (requestType === RedirectRequestTypes.authorization) { log('Potential authorization request ', currentUri, queryParams, @@ -167,9 +163,9 @@ export class RedirectRequestHandler extends AuthorizationRequestHandler { state: state }); } else { - if (requestType === RequestTypes.authorization) { + if (requestType === RedirectRequestTypes.authorization) { authorizationResponse = new AuthorizationResponse({code: code, state: state}); - } else if (requestType === RequestTypes.endSession) { + } else if (requestType === RedirectRequestTypes.endSession) { authorizationResponse = new EndSessionResponse({state: state}) } } From 4e6d7ce20892cb8617439d79b94067bbb2b77ddb Mon Sep 17 00:00:00 2001 From: Arsalan Salari Date: Sat, 11 Sep 2021 19:00:41 +0430 Subject: [PATCH 11/13] Add built files --- built/authorization_request_handler.d.ts | 17 ++++++++- built/authorization_request_handler.js | 29 ++++++++++++-- built/node_support/node_request_handler.d.ts | 6 ++- built/node_support/node_request_handler.js | 40 +++++++++++++++++--- built/redirect_based_handler.js | 32 ++++++++-------- built/types.d.ts | 4 ++ built/types.js | 8 +++- 7 files changed, 107 insertions(+), 29 deletions(-) diff --git a/built/authorization_request_handler.d.ts b/built/authorization_request_handler.d.ts index ffe5d80..cb5b816 100644 --- a/built/authorization_request_handler.d.ts +++ b/built/authorization_request_handler.d.ts @@ -4,6 +4,7 @@ import { AuthorizationError } from './authorization_management_response'; import { AuthorizationServiceConfiguration } from './authorization_service_configuration'; import { Crypto } from './crypto_utils'; import { QueryStringUtils } from './query_string_utils'; +import { RedirectRequestTypes } from './types'; /** * This type represents a lambda that can take an AuthorizationRequest, * and an AuthorizationResponse as arguments. @@ -41,11 +42,15 @@ export declare abstract class AuthorizationRequestHandler { /** * A utility method to be able to build the authorization request URL. */ - protected buildRequestUrl(configuration: AuthorizationServiceConfiguration, request: AuthorizationManagementRequest): string; + protected buildRequestUrl(configuration: AuthorizationServiceConfiguration, request: AuthorizationManagementRequest, requestType: RedirectRequestTypes): string; /** * Completes the authorization request if necessary & when possible. */ completeAuthorizationRequestIfPossible(): Promise; + /** + * Completes the endsession request if necessary & when possible. + */ + completeEndSessionRequestIfPossible(): Promise; /** * Sets the default Authorization Service notifier. */ @@ -54,10 +59,20 @@ export declare abstract class AuthorizationRequestHandler { * Makes an authorization request. */ abstract performAuthorizationRequest(configuration: AuthorizationServiceConfiguration, request: AuthorizationManagementRequest): void; + /** + * Makes an end session request. + */ + abstract performEndSessionRequest(configuration: AuthorizationServiceConfiguration, request: AuthorizationManagementRequest): void; /** * Checks if an authorization flow can be completed, and completes it. * The handler returns a `Promise` if ready, or a `Promise` * if not ready. */ protected abstract completeAuthorizationRequest(): Promise; + /** + * Checks if an end session flow can be completed, and completes it. + * The handler returns a `Promise` if ready, or a `Promise` + * if not ready. + */ + protected abstract completeEndSessionRequest(): Promise; } diff --git a/built/authorization_request_handler.js b/built/authorization_request_handler.js index 2fe8fe7..a963354 100644 --- a/built/authorization_request_handler.js +++ b/built/authorization_request_handler.js @@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true }); exports.AuthorizationRequestHandler = exports.AuthorizationNotifier = void 0; var logger_1 = require("./logger"); +var types_1 = require("./types"); /** * Authorization Service notifier. * This manages the communication of the AuthorizationResponse to the 3p client. @@ -52,12 +53,14 @@ var AuthorizationRequestHandler = /** @class */ (function () { /** * A utility method to be able to build the authorization request URL. */ - AuthorizationRequestHandler.prototype.buildRequestUrl = function (configuration, request) { + AuthorizationRequestHandler.prototype.buildRequestUrl = function (configuration, request, requestType) { // build the query string // coerce to any type for convenience var requestMap = request.toRequestMap(); var query = this.utils.stringify(requestMap); - var baseUrl = configuration.authorizationEndpoint; + var baseUrl = requestType === types_1.RedirectRequestTypes.authorization ? + configuration.authorizationEndpoint : + configuration.endSessionEndpoint; var url = baseUrl + "?" + query; return url; }; @@ -81,6 +84,26 @@ var AuthorizationRequestHandler = /** @class */ (function () { } }); }; + /** + * Completes the endsession request if necessary & when possible. + */ + AuthorizationRequestHandler.prototype.completeEndSessionRequestIfPossible = function () { + var _this = this; + // call complete endsession if possible to see there might + // be a response that needs to be delivered. + logger_1.log("Checking to see if there is an endsession response to be delivered."); + if (!this.notifier) { + logger_1.log("Notifier is not present on EndSessionRequest handler.\n No delivery of result will be possible"); + } + return this.completeEndSessionRequest().then(function (result) { + if (!result) { + logger_1.log("No result is available yet."); + } + if (result && _this.notifier) { + _this.notifier.onAuthorizationComplete(result.request, result.response, result.error); + } + }); + }; /** * Sets the default Authorization Service notifier. */ @@ -92,4 +115,4 @@ var AuthorizationRequestHandler = /** @class */ (function () { return AuthorizationRequestHandler; }()); exports.AuthorizationRequestHandler = AuthorizationRequestHandler; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorization_request_handler.js","sourceRoot":"","sources":["../src/authorization_request_handler.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AAOH,mCAA6B;AAuB7B;;;GAGG;AACH;IAAA;QACU,aAAQ,GAA+B,IAAI,CAAC;IAkBtD,CAAC;IAhBC,wDAAwB,GAAxB,UAAyB,QAA+B;QACtD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,uDAAuB,GAAvB,UACI,OAAuC,EACvC,QAA8C,EAC9C,KAA8B;QAChC,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,iCAAiC;YACjC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;SACzC;IACH,CAAC;IACH,4BAAC;AAAD,CAAC,AAnBD,IAmBC;AAnBY,sDAAqB;AAsBlC;;;GAGG;AACH;IACE,qCAAmB,KAAuB,EAAY,MAAc;QAAjD,UAAK,GAAL,KAAK,CAAkB;QAAY,WAAM,GAAN,MAAM,CAAQ;QAEpE,iDAAiD;QACvC,aAAQ,GAA+B,IAAI,CAAC;IAHiB,CAAC;IAKxE;;OAEG;IACO,qDAAe,GAAzB,UACI,aAAgD,EAChD,OAAuC;QACzC,yBAAyB;QACzB,qCAAqC;QACrC,IAAI,UAAU,GAAc,OAAO,CAAC,YAAY,EAAE,CAAA;QAClD,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAC7C,IAAI,OAAO,GAAG,aAAa,CAAC,qBAAqB,CAAC;QAClD,IAAI,GAAG,GAAM,OAAO,SAAI,KAAO,CAAC;QAChC,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;OAEG;IACH,4EAAsC,GAAtC;QAAA,iBAgBC;QAfC,6DAA6D;QAC7D,4CAA4C;QAC5C,YAAG,CAAC,wEAAwE,CAAC,CAAC;QAC9E,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,YAAG,CAAC,4GACuC,CAAC,CAAA;SAC7C;QACD,OAAO,IAAI,CAAC,4BAA4B,EAAE,CAAC,IAAI,CAAC,UAAA,MAAM;YACpD,IAAI,CAAC,MAAM,EAAE;gBACX,YAAG,CAAC,6BAA6B,CAAC,CAAC;aACpC;YACD,IAAI,MAAM,IAAI,KAAI,CAAC,QAAQ,EAAE;gBAC3B,KAAI,CAAC,QAAQ,CAAC,uBAAuB,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;aACtF;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,8DAAwB,GAAxB,UAAyB,QAA+B;QACtD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IAAA,CAAC;IAeJ,kCAAC;AAAD,CAAC,AA/DD,IA+DC;AA/DqB,kEAA2B","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {AuthorizationManagementRequest} from './authorization_management_request';\nimport {AuthorizationManagementResponse} from './authorization_management_response';\nimport {AuthorizationError} from './authorization_management_response';\nimport {AuthorizationServiceConfiguration} from './authorization_service_configuration';\nimport {Crypto} from './crypto_utils';\nimport {log} from './logger';\nimport {QueryStringUtils} from './query_string_utils';\nimport {StringMap} from './types';\n\n\n/**\n * This type represents a lambda that can take an AuthorizationRequest,\n * and an AuthorizationResponse as arguments.\n */\nexport type AuthorizationListener =\n    (request: AuthorizationManagementRequest,\n     response: AuthorizationManagementResponse|null,\n     error: AuthorizationError|null) => void;\n\n/**\n * Represents a structural type holding both authorization request and response.\n */\nexport interface AuthorizationRequestResponse {\n  request: AuthorizationManagementRequest;\n  response: AuthorizationManagementResponse|null;\n  error: AuthorizationError|null;\n}\n\n/**\n * Authorization Service notifier.\n * This manages the communication of the AuthorizationResponse to the 3p client.\n */\nexport class AuthorizationNotifier {\n  private listener: AuthorizationListener|null = null;\n\n  setAuthorizationListener(listener: AuthorizationListener) {\n    this.listener = listener;\n  }\n\n  /**\n   * The authorization complete callback.\n   */\n  onAuthorizationComplete(\n      request: AuthorizationManagementRequest,\n      response: AuthorizationManagementResponse|null,\n      error: AuthorizationError|null): void {\n    if (this.listener) {\n      // complete authorization request\n      this.listener(request, response, error);\n    }\n  }\n}\n\n\n/**\n * Defines the interface which is capable of handling an authorization request\n * using various methods (iframe / popup / different process etc.).\n */\nexport abstract class AuthorizationRequestHandler {\n  constructor(public utils: QueryStringUtils, protected crypto: Crypto) {}\n\n  // notifier send the response back to the client.\n  protected notifier: AuthorizationNotifier|null = null;\n\n  /**\n   * A utility method to be able to build the authorization request URL.\n   */\n  protected buildRequestUrl(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationManagementRequest) {\n    // build the query string\n    // coerce to any type for convenience\n    let requestMap: StringMap = request.toRequestMap()\n    let query = this.utils.stringify(requestMap);\n    let baseUrl = configuration.authorizationEndpoint;\n    let url = `${baseUrl}?${query}`;\n    return url;\n  }\n\n  /**\n   * Completes the authorization request if necessary & when possible.\n   */\n  completeAuthorizationRequestIfPossible(): Promise<void> {\n    // call complete authorization if possible to see there might\n    // be a response that needs to be delivered.\n    log(`Checking to see if there is an authorization response to be delivered.`);\n    if (!this.notifier) {\n      log(`Notifier is not present on AuthorizationRequest handler.\n          No delivery of result will be possible`)\n    }\n    return this.completeAuthorizationRequest().then(result => {\n      if (!result) {\n        log(`No result is available yet.`);\n      }\n      if (result && this.notifier) {\n        this.notifier.onAuthorizationComplete(result.request, result.response, result.error);\n      }\n    });\n  }\n\n  /**\n   * Sets the default Authorization Service notifier.\n   */\n  setAuthorizationNotifier(notifier: AuthorizationNotifier): AuthorizationRequestHandler {\n    this.notifier = notifier;\n    return this;\n  };\n\n  /**\n   * Makes an authorization request.\n   */\n  abstract performAuthorizationRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationManagementRequest): void;\n\n  /**\n   * Checks if an authorization flow can be completed, and completes it.\n   * The handler returns a `Promise<AuthorizationRequestResponse>` if ready, or a `Promise<null>`\n   * if not ready.\n   */\n  protected abstract completeAuthorizationRequest(): Promise<AuthorizationRequestResponse|null>;\n}\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorization_request_handler.js","sourceRoot":"","sources":["../src/authorization_request_handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {AuthorizationManagementRequest} from './authorization_management_request';\nimport {AuthorizationManagementResponse} from './authorization_management_response';\nimport {AuthorizationError} from './authorization_management_response';\nimport {AuthorizationServiceConfiguration} from './authorization_service_configuration';\nimport {Crypto} from './crypto_utils';\nimport {log} from './logger';\nimport {QueryStringUtils} from './query_string_utils';\nimport {RedirectRequestTypes, StringMap} from './types';\n\n\n/**\n * This type represents a lambda that can take an AuthorizationRequest,\n * and an AuthorizationResponse as arguments.\n */\nexport type AuthorizationListener =\n    (request: AuthorizationManagementRequest,\n     response: AuthorizationManagementResponse|null,\n     error: AuthorizationError|null) => void;\n\n/**\n * Represents a structural type holding both authorization request and response.\n */\nexport interface AuthorizationRequestResponse {\n  request: AuthorizationManagementRequest;\n  response: AuthorizationManagementResponse|null;\n  error: AuthorizationError|null;\n}\n\n/**\n * Authorization Service notifier.\n * This manages the communication of the AuthorizationResponse to the 3p client.\n */\nexport class AuthorizationNotifier {\n  private listener: AuthorizationListener|null = null;\n\n  setAuthorizationListener(listener: AuthorizationListener) {\n    this.listener = listener;\n  }\n\n  /**\n   * The authorization complete callback.\n   */\n  onAuthorizationComplete(\n      request: AuthorizationManagementRequest,\n      response: AuthorizationManagementResponse|null,\n      error: AuthorizationError|null): void {\n    if (this.listener) {\n      // complete authorization request\n      this.listener(request, response, error);\n    }\n  }\n}\n\n\n/**\n * Defines the interface which is capable of handling an authorization request\n * using various methods (iframe / popup / different process etc.).\n */\nexport abstract class AuthorizationRequestHandler {\n  constructor(public utils: QueryStringUtils, protected crypto: Crypto) {}\n\n  // notifier send the response back to the client.\n  protected notifier: AuthorizationNotifier|null = null;\n\n  /**\n   * A utility method to be able to build the authorization request URL.\n   */\n  protected buildRequestUrl(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationManagementRequest,\n      requestType: RedirectRequestTypes) {\n    // build the query string\n    // coerce to any type for convenience\n    let requestMap: StringMap = request.toRequestMap()\n    let query = this.utils.stringify(requestMap);\n    let baseUrl = requestType === RedirectRequestTypes.authorization ?\n        configuration.authorizationEndpoint :\n        configuration.endSessionEndpoint;\n    let url = `${baseUrl}?${query}`;\n    return url;\n  }\n\n  /**\n   * Completes the authorization request if necessary & when possible.\n   */\n  completeAuthorizationRequestIfPossible(): Promise<void> {\n    // call complete authorization if possible to see there might\n    // be a response that needs to be delivered.\n    log(`Checking to see if there is an authorization response to be delivered.`);\n    if (!this.notifier) {\n      log(`Notifier is not present on AuthorizationRequest handler.\n          No delivery of result will be possible`)\n    }\n    return this.completeAuthorizationRequest().then(result => {\n      if (!result) {\n        log(`No result is available yet.`);\n      }\n      if (result && this.notifier) {\n        this.notifier.onAuthorizationComplete(result.request, result.response, result.error);\n      }\n    });\n  }\n\n  /**\n   * Completes the endsession request if necessary & when possible.\n   */\n  completeEndSessionRequestIfPossible(): Promise<void> {\n    // call complete endsession if possible to see there might\n    // be a response that needs to be delivered.\n    log(`Checking to see if there is an endsession response to be delivered.`);\n    if (!this.notifier) {\n      log(`Notifier is not present on EndSessionRequest handler.\n          No delivery of result will be possible`)\n    }\n    return this.completeEndSessionRequest().then(result => {\n      if (!result) {\n        log(`No result is available yet.`);\n      }\n      if (result && this.notifier) {\n        this.notifier.onAuthorizationComplete(result.request, result.response, result.error);\n      }\n    });\n  }\n\n  /**\n   * Sets the default Authorization Service notifier.\n   */\n  setAuthorizationNotifier(notifier: AuthorizationNotifier): AuthorizationRequestHandler {\n    this.notifier = notifier;\n    return this;\n  };\n\n  /**\n   * Makes an authorization request.\n   */\n  abstract performAuthorizationRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationManagementRequest): void;\n\n  /**\n   * Makes an end session request.\n   */\n  abstract performEndSessionRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationManagementRequest): void;\n  /**\n   * Checks if an authorization flow can be completed, and completes it.\n   * The handler returns a `Promise<AuthorizationRequestResponse>` if ready, or a `Promise<null>`\n   * if not ready.\n   */\n  protected abstract completeAuthorizationRequest(): Promise<AuthorizationRequestResponse|null>;\n\n  /**\n   * Checks if an end session flow can be completed, and completes it.\n   * The handler returns a `Promise<AuthorizationRequestResponse>` if ready, or a `Promise<null>`\n   * if not ready.\n   */\n  protected abstract completeEndSessionRequest(): Promise<AuthorizationRequestResponse|null>;\n}\n"]} \ No newline at end of file diff --git a/built/node_support/node_request_handler.d.ts b/built/node_support/node_request_handler.d.ts index 3728765..bd0b378 100644 --- a/built/node_support/node_request_handler.d.ts +++ b/built/node_support/node_request_handler.d.ts @@ -1,12 +1,16 @@ -import { AuthorizationRequest } from '../authorization_request'; import { AuthorizationRequestHandler, AuthorizationRequestResponse } from '../authorization_request_handler'; import { AuthorizationServiceConfiguration } from '../authorization_service_configuration'; import { Crypto } from '../crypto_utils'; import { QueryStringUtils } from '../query_string_utils'; +import { AuthorizationRequest } from '../authorization_request'; export declare class NodeBasedHandler extends AuthorizationRequestHandler { httpServerPort: number; authorizationPromise: Promise | null; constructor(httpServerPort?: number, utils?: QueryStringUtils, crypto?: Crypto); performAuthorizationRequest(configuration: AuthorizationServiceConfiguration, request: AuthorizationRequest): void; + performEndSessionRequest(configuration: AuthorizationServiceConfiguration, request: AuthorizationRequest): void; + private performRequest; protected completeAuthorizationRequest(): Promise; + protected completeEndSessionRequest(): Promise; + private completeRequest; } diff --git a/built/node_support/node_request_handler.js b/built/node_support/node_request_handler.js index c26af31..e3e9adf 100644 --- a/built/node_support/node_request_handler.js +++ b/built/node_support/node_request_handler.js @@ -38,8 +38,11 @@ var authorization_management_response_1 = require("../authorization_management_r var logger_1 = require("../logger"); var query_string_utils_1 = require("../query_string_utils"); var crypto_utils_1 = require("./crypto_utils"); +var types_1 = require("../types"); +var end_session_response_1 = require("../end_session_response"); // TypeScript typings for `opener` are not correct and do not export it as module var opener = require("opener"); +var authorization_request_1 = require("../authorization_request"); var ServerEventsEmitter = /** @class */ (function (_super) { __extends(ServerEventsEmitter, _super); function ServerEventsEmitter() { @@ -64,6 +67,12 @@ var NodeBasedHandler = /** @class */ (function (_super) { return _this; } NodeBasedHandler.prototype.performAuthorizationRequest = function (configuration, request) { + this.performRequest(configuration, request, types_1.RedirectRequestTypes.authorization); + }; + NodeBasedHandler.prototype.performEndSessionRequest = function (configuration, request) { + this.performRequest(configuration, request, types_1.RedirectRequestTypes.endSession); + }; + NodeBasedHandler.prototype.performRequest = function (configuration, request, requestType) { var _this = this; // use opener to launch a web browser and start the authorization flow. // start a web server to handle the authorization response. @@ -81,7 +90,12 @@ var NodeBasedHandler = /** @class */ (function (_super) { // ignore irrelevant requests (e.g. favicon.ico) return; } - logger_1.log('Handling Authorization Request ', searchParams, state, code, error); + if (requestType === types_1.RedirectRequestTypes.authorization) { + logger_1.log('Handling Authorization Request ', searchParams, state, code, error); + } + else if (requestType === types_1.RedirectRequestTypes.endSession) { + logger_1.log('Handling end session Request ', searchParams, state, error); + } var authorizationResponse = null; var authorizationError = null; if (error) { @@ -92,7 +106,12 @@ var NodeBasedHandler = /** @class */ (function (_super) { authorizationError = new authorization_management_response_1.AuthorizationError({ error: error, error_description: errorDescription, error_uri: errorUri, state: state }); } else { - authorizationResponse = new authorization_response_1.AuthorizationResponse({ code: code, state: state }); + if (requestType === types_1.RedirectRequestTypes.authorization) { + authorizationResponse = new authorization_response_1.AuthorizationResponse({ code: code, state: state }); + } + else if (requestType === types_1.RedirectRequestTypes.endSession) { + authorizationResponse = new end_session_response_1.EndSessionResponse({ state: state }); + } } var completeResponse = { request: request, @@ -115,11 +134,14 @@ var NodeBasedHandler = /** @class */ (function (_super) { }); }); var server; - request.setupCodeVerifier() - .then(function () { + var codeVerified = Promise.resolve(); + if (request instanceof authorization_request_1.AuthorizationRequest) { + codeVerified = request.setupCodeVerifier(); + } + codeVerified.then(function () { server = Http.createServer(requestHandler); server.listen(_this.httpServerPort); - var url = _this.buildRequestUrl(configuration, request); + var url = _this.buildRequestUrl(configuration, request, requestType); logger_1.log('Making a request to ', request, url); opener(url); }) @@ -129,6 +151,12 @@ var NodeBasedHandler = /** @class */ (function (_super) { }); }; NodeBasedHandler.prototype.completeAuthorizationRequest = function () { + return this.completeRequest(); + }; + NodeBasedHandler.prototype.completeEndSessionRequest = function () { + return this.completeRequest(); + }; + NodeBasedHandler.prototype.completeRequest = function () { if (!this.authorizationPromise) { return Promise.reject('No pending authorization request. Call performAuthorizationRequest() ?'); } @@ -137,4 +165,4 @@ var NodeBasedHandler = /** @class */ (function (_super) { return NodeBasedHandler; }(authorization_request_handler_1.AuthorizationRequestHandler)); exports.NodeBasedHandler = NodeBasedHandler; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node_request_handler.js","sourceRoot":"","sources":["../../src/node_support/node_request_handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {EventEmitter} from 'events';\nimport * as Http from 'http';\nimport * as Url from 'url';\nimport {AuthorizationRequest} from '../authorization_request';\nimport {AuthorizationRequestHandler, AuthorizationRequestResponse} from '../authorization_request_handler';\nimport {AuthorizationResponse} from '../authorization_response';\nimport {AuthorizationError} from '../authorization_management_response';\nimport {AuthorizationServiceConfiguration} from '../authorization_service_configuration';\nimport {Crypto} from '../crypto_utils';\nimport {log} from '../logger';\nimport {BasicQueryStringUtils, QueryStringUtils} from '../query_string_utils';\nimport {NodeCrypto} from './crypto_utils';\n\n\n// TypeScript typings for `opener` are not correct and do not export it as module\nimport opener = require('opener');\n\nclass ServerEventsEmitter extends EventEmitter {\n  static ON_UNABLE_TO_START = 'unable_to_start';\n  static ON_AUTHORIZATION_RESPONSE = 'authorization_response';\n}\n\nexport class NodeBasedHandler extends AuthorizationRequestHandler {\n  // the handle to the current authorization request\n  authorizationPromise: Promise<AuthorizationRequestResponse|null>|null = null;\n\n  constructor(\n      // default to port 8000\n      public httpServerPort = 8000,\n      utils: QueryStringUtils = new BasicQueryStringUtils(),\n      crypto: Crypto = new NodeCrypto()) {\n    super(utils, crypto);\n  }\n\n  performAuthorizationRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationRequest) {\n    // use opener to launch a web browser and start the authorization flow.\n    // start a web server to handle the authorization response.\n    const emitter = new ServerEventsEmitter();\n\n    const requestHandler = (httpRequest: Http.IncomingMessage, response: Http.ServerResponse) => {\n      if (!httpRequest.url) {\n        return;\n      }\n\n      const url = Url.parse(httpRequest.url);\n      const searchParams = new Url.URLSearchParams(url.query || '');\n\n      const state = searchParams.get('state') || undefined;\n      const code = searchParams.get('code');\n      const error = searchParams.get('error');\n\n      if (!state && !code && !error) {\n        // ignore irrelevant requests (e.g. favicon.ico)\n        return;\n      }\n\n      log('Handling Authorization Request ', searchParams, state, code, error);\n      let authorizationResponse: AuthorizationResponse|null = null;\n      let authorizationError: AuthorizationError|null = null;\n      if (error) {\n        log('error');\n        // get additional optional info.\n        const errorUri = searchParams.get('error_uri') || undefined;\n        const errorDescription = searchParams.get('error_description') || undefined;\n        authorizationError = new AuthorizationError(\n            {error: error, error_description: errorDescription, error_uri: errorUri, state: state});\n      } else {\n        authorizationResponse = new AuthorizationResponse({code: code!, state: state!});\n      }\n      const completeResponse = {\n        request,\n        response: authorizationResponse,\n        error: authorizationError\n      } as AuthorizationRequestResponse;\n      emitter.emit(ServerEventsEmitter.ON_AUTHORIZATION_RESPONSE, completeResponse);\n      response.end('Close your browser to continue');\n    };\n\n    this.authorizationPromise = new Promise<AuthorizationRequestResponse>((resolve, reject) => {\n      emitter.once(ServerEventsEmitter.ON_UNABLE_TO_START, () => {\n        reject(`Unable to create HTTP server at port ${this.httpServerPort}`);\n      });\n      emitter.once(ServerEventsEmitter.ON_AUTHORIZATION_RESPONSE, (result: any) => {\n        server.close();\n        // resolve pending promise\n        resolve(result as AuthorizationRequestResponse);\n        // complete authorization flow\n        this.completeAuthorizationRequestIfPossible();\n      });\n    });\n\n    let server: Http.Server;\n    request.setupCodeVerifier()\n        .then(() => {\n          server = Http.createServer(requestHandler);\n          server.listen(this.httpServerPort);\n          const url = this.buildRequestUrl(configuration, request);\n          log('Making a request to ', request, url);\n          opener(url);\n        })\n        .catch((error) => {\n          log('Something bad happened ', error);\n          emitter.emit(ServerEventsEmitter.ON_UNABLE_TO_START);\n        });\n  }\n\n  protected completeAuthorizationRequest(): Promise<AuthorizationRequestResponse|null> {\n    if (!this.authorizationPromise) {\n      return Promise.reject(\n          'No pending authorization request. Call performAuthorizationRequest() ?');\n    }\n\n    return this.authorizationPromise;\n  }\n}\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node_request_handler.js","sourceRoot":"","sources":["../../src/node_support/node_request_handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {EventEmitter} from 'events';\nimport * as Http from 'http';\nimport * as Url from 'url';\nimport {AuthorizationManagementRequest} from '../authorization_management_request';\nimport {AuthorizationRequestHandler, AuthorizationRequestResponse} from '../authorization_request_handler';\nimport {AuthorizationResponse} from '../authorization_response';\nimport {AuthorizationError} from '../authorization_management_response';\nimport {AuthorizationServiceConfiguration} from '../authorization_service_configuration';\nimport {Crypto} from '../crypto_utils';\nimport {log} from '../logger';\nimport {BasicQueryStringUtils, QueryStringUtils} from '../query_string_utils';\nimport {NodeCrypto} from './crypto_utils';\nimport {RedirectRequestTypes} from '../types';\nimport {EndSessionResponse} from '../end_session_response';\n\n\n// TypeScript typings for `opener` are not correct and do not export it as module\nimport opener = require('opener');\nimport { AuthorizationRequest } from '../authorization_request';\n\nclass ServerEventsEmitter extends EventEmitter {\n  static ON_UNABLE_TO_START = 'unable_to_start';\n  static ON_AUTHORIZATION_RESPONSE = 'authorization_response';\n}\n\nexport class NodeBasedHandler extends AuthorizationRequestHandler {\n  // the handle to the current authorization request\n  authorizationPromise: Promise<AuthorizationRequestResponse|null>|null = null;\n\n  constructor(\n      // default to port 8000\n      public httpServerPort = 8000,\n      utils: QueryStringUtils = new BasicQueryStringUtils(),\n      crypto: Crypto = new NodeCrypto()) {\n    super(utils, crypto);\n  }\n\n  performAuthorizationRequest(configuration: AuthorizationServiceConfiguration, request: AuthorizationRequest){\n    this.performRequest(configuration, request, RedirectRequestTypes.authorization);\n  }\n\n  performEndSessionRequest(configuration: AuthorizationServiceConfiguration, request: AuthorizationRequest){\n    this.performRequest(configuration, request, RedirectRequestTypes.endSession);\n  }\n  \n  private performRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationManagementRequest, \n      requestType: RedirectRequestTypes) {\n    // use opener to launch a web browser and start the authorization flow.\n    // start a web server to handle the authorization response.\n    const emitter = new ServerEventsEmitter();\n\n    const requestHandler = (httpRequest: Http.IncomingMessage, response: Http.ServerResponse) => {\n      if (!httpRequest.url) {\n        return;\n      }\n\n      const url = Url.parse(httpRequest.url);\n      const searchParams = new Url.URLSearchParams(url.query || '');\n\n      const state = searchParams.get('state') || undefined;\n      const code = searchParams.get('code');\n      const error = searchParams.get('error');\n\n      if (!state && !code && !error) {\n        // ignore irrelevant requests (e.g. favicon.ico)\n        return;\n      }\n\n      if(requestType === RedirectRequestTypes.authorization){\n        log('Handling Authorization Request ', searchParams, state, code, error);\n      } else if(requestType === RedirectRequestTypes.endSession){\n        log('Handling end session Request ', searchParams, state, error);\n      }\n      let authorizationResponse: EndSessionResponse|AuthorizationResponse|null = null;\n      let authorizationError: AuthorizationError|null = null;\n      if (error) {\n        log('error');\n        // get additional optional info.\n        const errorUri = searchParams.get('error_uri') || undefined;\n        const errorDescription = searchParams.get('error_description') || undefined;\n        authorizationError = new AuthorizationError(\n            {error: error, error_description: errorDescription, error_uri: errorUri, state: state});\n      } else {\n        if (requestType === RedirectRequestTypes.authorization) {\n          authorizationResponse = new AuthorizationResponse({code: code!, state: state!});\n        } else if (requestType === RedirectRequestTypes.endSession) {\n          authorizationResponse = new EndSessionResponse({state: state!})\n        }\n      }\n      const completeResponse = {\n        request,\n        response: authorizationResponse,\n        error: authorizationError\n      } as AuthorizationRequestResponse;\n      emitter.emit(ServerEventsEmitter.ON_AUTHORIZATION_RESPONSE, completeResponse);\n      response.end('Close your browser to continue');\n    };\n\n    this.authorizationPromise = new Promise<AuthorizationRequestResponse>((resolve, reject) => {\n      emitter.once(ServerEventsEmitter.ON_UNABLE_TO_START, () => {\n        reject(`Unable to create HTTP server at port ${this.httpServerPort}`);\n      });\n      emitter.once(ServerEventsEmitter.ON_AUTHORIZATION_RESPONSE, (result: any) => {\n        server.close();\n        // resolve pending promise\n        resolve(result as AuthorizationRequestResponse);\n        // complete authorization flow\n        this.completeAuthorizationRequestIfPossible();\n      });\n    });\n\n    let server: Http.Server;\n    let codeVerified: Promise<any> = Promise.resolve();\n    if(request instanceof AuthorizationRequest){\n      codeVerified = request.setupCodeVerifier()\n    }\n\n        codeVerified.then(() => {\n          server = Http.createServer(requestHandler);\n          server.listen(this.httpServerPort);\n          const url = this.buildRequestUrl(configuration, request, requestType);\n          log('Making a request to ', request, url);\n          opener(url);\n        })\n        .catch((error) => {\n          log('Something bad happened ', error);\n          emitter.emit(ServerEventsEmitter.ON_UNABLE_TO_START);\n        });\n  }\n\n  protected completeAuthorizationRequest(): Promise<AuthorizationRequestResponse|null> {\n    return this.completeRequest();\n  }\n\n  protected completeEndSessionRequest(): Promise<AuthorizationRequestResponse|null> {\n    return this.completeRequest();\n  }\n\n  private completeRequest(): Promise<AuthorizationRequestResponse|null> {\n    if (!this.authorizationPromise) {\n      return Promise.reject(\n          'No pending authorization request. Call performAuthorizationRequest() ?');\n    }\n\n    return this.authorizationPromise;\n  }\n}\n"]} \ No newline at end of file diff --git a/built/redirect_based_handler.js b/built/redirect_based_handler.js index 25001c5..b851729 100644 --- a/built/redirect_based_handler.js +++ b/built/redirect_based_handler.js @@ -39,11 +39,7 @@ var end_session_response_1 = require("./end_session_response"); var logger_1 = require("./logger"); var query_string_utils_1 = require("./query_string_utils"); var storage_1 = require("./storage"); -var RequestTypes; -(function (RequestTypes) { - RequestTypes["endSession"] = "end_session"; - RequestTypes["authorization"] = "authorization"; -})(RequestTypes || (RequestTypes = {})); +var types_1 = require("./types"); /** key for authorization request. */ var requestKey = function (handle, requestType) { return handle + "_appauth_" + requestType + "_request"; @@ -53,7 +49,9 @@ var serviceConfigurationKey = function (handle, requestType) { return handle + "_appauth_" + requestType + "_service_configuration"; }; /** key in local storage which represents the current authorization request. */ -var REQUEST_HANDLE_KEY = function (requestType) { return "appauth_current_" + requestType + "_request"; }; +var REQUEST_HANDLE_KEY = function (requestType) { + return "appauth_current_" + requestType + "_request"; +}; /** * Represents an AuthorizationRequestHandler which uses a standard * redirect based code flow. @@ -75,14 +73,14 @@ var RedirectRequestHandler = /** @class */ (function (_super) { return _this; } RedirectRequestHandler.prototype.performAuthorizationRequest = function (configuration, request) { - this.performRequest(configuration, request, RequestTypes.authorization); + this.performRequest(configuration, request, types_1.RedirectRequestTypes.authorization); }; RedirectRequestHandler.prototype.performEndSessionRequest = function (configuration, request) { - this.performRequest(configuration, request, RequestTypes.endSession); + this.performRequest(configuration, request, types_1.RedirectRequestTypes.endSession); }; RedirectRequestHandler.prototype.performRequest = function (configuration, request, requestType) { var _this = this; - if (requestType === void 0) { requestType = RequestTypes.authorization; } + if (requestType === void 0) { requestType = types_1.RedirectRequestTypes.authorization; } var handle = this.crypto.generateRandom(10); // before you make request, persist all request related data in local storage. var persisted = Promise.all([ @@ -95,7 +93,7 @@ var RedirectRequestHandler = /** @class */ (function (_super) { ]); persisted.then(function () { // make the redirect request - var url = _this.buildRequestUrl(configuration, request); + var url = _this.buildRequestUrl(configuration, request, requestType); logger_1.log('Making a request to ', request, url); _this.locationLike.assign(url); }); @@ -105,14 +103,14 @@ var RedirectRequestHandler = /** @class */ (function (_super) { * authorization request. */ RedirectRequestHandler.prototype.completeAuthorizationRequest = function () { - return this.completeRequest(RequestTypes.authorization); + return this.completeRequest(types_1.RedirectRequestTypes.authorization); }; /** * Attempts to introspect the contents of storage backend and completes the * end session request. */ RedirectRequestHandler.prototype.completeEndSessionRequest = function () { - return this.completeRequest(RequestTypes.endSession); + return this.completeRequest(types_1.RedirectRequestTypes.endSession); }; /** * Attempts to introspect the contents of storage backend and completes the @@ -130,7 +128,7 @@ var RedirectRequestHandler = /** @class */ (function (_super) { // requires a corresponding instance of result // TODO(rahulrav@): check for inconsistent state here .then(function (result) { return JSON.parse(result); }) - .then(function (json) { return requestType === RequestTypes.authorization ? + .then(function (json) { return requestType === types_1.RedirectRequestTypes.authorization ? new authorization_request_1.AuthorizationRequest(json) : new end_session_request_1.EndSessionRequest(json); }) .then(function (request) { @@ -140,7 +138,7 @@ var RedirectRequestHandler = /** @class */ (function (_super) { var state = queryParams['state']; var code = queryParams['code']; var error = queryParams['error']; - if (requestType === RequestTypes.authorization) { + if (requestType === types_1.RedirectRequestTypes.authorization) { logger_1.log('Potential authorization request ', currentUri, queryParams, state, code, error); } else { @@ -162,10 +160,10 @@ var RedirectRequestHandler = /** @class */ (function (_super) { }); } else { - if (requestType === RequestTypes.authorization) { + if (requestType === types_1.RedirectRequestTypes.authorization) { authorizationResponse = new authorization_response_1.AuthorizationResponse({ code: code, state: state }); } - else if (requestType === RequestTypes.endSession) { + else if (requestType === types_1.RedirectRequestTypes.endSession) { authorizationResponse = new end_session_response_1.EndSessionResponse({ state: state }); } } @@ -199,4 +197,4 @@ var RedirectRequestHandler = /** @class */ (function (_super) { return RedirectRequestHandler; }(authorization_request_handler_1.AuthorizationRequestHandler)); exports.RedirectRequestHandler = RedirectRequestHandler; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redirect_based_handler.js","sourceRoot":"","sources":["../src/redirect_based_handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {AuthorizationManagementRequest} from './authorization_management_request';\nimport {AuthorizationError} from './authorization_management_response';\nimport {AuthorizationRequest} from './authorization_request';\nimport {AuthorizationRequestHandler, AuthorizationRequestResponse} from './authorization_request_handler';\nimport {AuthorizationResponse} from './authorization_response'\nimport {AuthorizationServiceConfiguration} from './authorization_service_configuration';\nimport {Crypto, DefaultCrypto} from './crypto_utils';\nimport {EndSessionRequest} from './end_session_request';\nimport {EndSessionResponse} from './end_session_response';\nimport {log} from './logger';\nimport {BasicQueryStringUtils} from './query_string_utils';\nimport {LocalStorageBackend, StorageBackend} from './storage';\nimport {LocationLike} from './types';\n\n\nenum RequestTypes {\n  endSession = 'end_session',\n  authorization = 'authorization'\n}\n\n/** key for authorization request. */\nconst requestKey =\n    (handle: string, requestType: RequestTypes) => {\n      return `${handle}_appauth_${requestType}_request`;\n    }\n\n/** key for authorization service configuration */\nconst serviceConfigurationKey =\n    (handle: string, requestType: RequestTypes) => {\n      return `${handle}_appauth_${requestType}_service_configuration`;\n    }\n\n/** key in local storage which represents the current authorization request. */\nconst REQUEST_HANDLE_KEY = (requestType: RequestTypes) => `appauth_current_${requestType}_request`;\n\n/**\n * Represents an AuthorizationRequestHandler which uses a standard\n * redirect based code flow.\n */\nexport class RedirectRequestHandler extends AuthorizationRequestHandler {\n  constructor(\n      // use the provided storage backend\n      // or initialize local storage with the default storage backend which\n      // uses window.localStorage\n      public storageBackend: StorageBackend = new LocalStorageBackend(),\n      utils = new BasicQueryStringUtils(),\n      public locationLike: LocationLike = window.location,\n      crypto: Crypto = new DefaultCrypto()) {\n    super(utils, crypto);\n  }\n\n  performAuthorizationRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationRequest) {\n    this.performRequest(configuration, request, RequestTypes.authorization);\n  }\n\n  performEndSessionRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: EndSessionRequest) {\n    this.performRequest(configuration, request, RequestTypes.endSession);\n  }\n\n  private performRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationManagementRequest,\n      requestType: RequestTypes = RequestTypes.authorization) {\n    const handle = this.crypto.generateRandom(10);\n\n    // before you make request, persist all request related data in local storage.\n    const persisted = Promise.all([\n      this.storageBackend.setItem(REQUEST_HANDLE_KEY(requestType), handle),\n      // Calling toJson() adds in the code & challenge when possible\n      request.toJson().then(\n          result =>\n              this.storageBackend.setItem(requestKey(handle, requestType), JSON.stringify(result))),\n      this.storageBackend.setItem(\n          serviceConfigurationKey(handle, requestType), JSON.stringify(configuration.toJson())),\n    ]);\n\n    persisted.then(() => {\n      // make the redirect request\n      let url = this.buildRequestUrl(configuration, request);\n      log('Making a request to ', request, url);\n      this.locationLike.assign(url);\n    });\n  }\n\n  /**\n   * Attempts to introspect the contents of storage backend and completes the\n   *  authorization request.\n   */\n  protected completeAuthorizationRequest(): Promise<AuthorizationRequestResponse|null> {\n    return this.completeRequest(RequestTypes.authorization);\n  }\n\n  /**\n   * Attempts to introspect the contents of storage backend and completes the\n   * end session request.\n   */\n  protected completeEndSessionRequest(): Promise<AuthorizationRequestResponse|null> {\n    return this.completeRequest(RequestTypes.endSession);\n  }\n\n  /**\n   * Attempts to introspect the contents of storage backend and completes the\n   * request.\n   */\n  private completeRequest(requestType: RequestTypes) {\n    // TODO(rahulrav@): handle authorization errors.\n    return this.storageBackend.getItem(REQUEST_HANDLE_KEY(requestType)).then(handle => {\n      if (handle) {\n        // we have a pending request.\n        // fetch authorization request, and check state\n        return this.storageBackend\n            .getItem(requestKey(handle, requestType))\n            // requires a corresponding instance of result\n            // TODO(rahulrav@): check for inconsistent state here\n            .then(result => JSON.parse(result!))\n            .then(\n                json => requestType === RequestTypes.authorization ?\n                    new AuthorizationRequest(json) :\n                    new EndSessionRequest(json))\n            .then(request => {\n              // check redirect_uri and state\n              let currentUri = `${this.locationLike.origin}${this.locationLike.pathname}`;\n              let queryParams = this.utils.parse(this.locationLike, true /* use hash */);\n              let state: string|undefined = queryParams['state'];\n              let code: string|undefined = queryParams['code'];\n              let error: string|undefined = queryParams['error'];\n              if (requestType === RequestTypes.authorization) {\n                log('Potential authorization request ',\n                    currentUri,\n                    queryParams,\n                    state,\n                    code,\n                    error);\n              } else {\n                log('Potential end session request ', currentUri, queryParams, state, error)\n              }\n              let shouldNotify = state === request.state;\n              let authorizationResponse: EndSessionResponse|AuthorizationResponse|null = null;\n              let authorizationError: AuthorizationError|null = null;\n              if (shouldNotify) {\n                if (error) {\n                  // get additional optional info.\n                  let errorUri = queryParams['error_uri'];\n                  let errorDescription = queryParams['error_description'];\n                  authorizationError = new AuthorizationError({\n                    error: error,\n                    error_description: errorDescription,\n                    error_uri: errorUri,\n                    state: state\n                  });\n                } else {\n                  if (requestType === RequestTypes.authorization) {\n                    authorizationResponse = new AuthorizationResponse({code: code, state: state});\n                  } else if (requestType === RequestTypes.endSession) {\n                    authorizationResponse = new EndSessionResponse({state: state})\n                  }\n                }\n                // cleanup state\n                return Promise\n                    .all([\n                      this.storageBackend.removeItem(REQUEST_HANDLE_KEY(requestType)),\n                      this.storageBackend.removeItem(requestKey(handle, requestType)),\n                      this.storageBackend.removeItem(serviceConfigurationKey(handle, requestType))\n                    ])\n                    .then(() => {\n                      log('Delivering authorization response');\n                      return {\n                        request: request,\n                        response: authorizationResponse,\n                        error: authorizationError\n                      } as AuthorizationRequestResponse;\n                    });\n              } else {\n                log('Mismatched request (state and request_uri) dont match.');\n                return Promise.resolve(null);\n              }\n            });\n      } else {\n        return null;\n      }\n    });\n  }\n}\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redirect_based_handler.js","sourceRoot":"","sources":["../src/redirect_based_handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the\n * License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n * express or implied. See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {AuthorizationManagementRequest} from './authorization_management_request';\nimport {AuthorizationError} from './authorization_management_response';\nimport {AuthorizationRequest} from './authorization_request';\nimport {AuthorizationRequestHandler, AuthorizationRequestResponse} from './authorization_request_handler';\nimport {AuthorizationResponse} from './authorization_response'\nimport {AuthorizationServiceConfiguration} from './authorization_service_configuration';\nimport {Crypto, DefaultCrypto} from './crypto_utils';\nimport {EndSessionRequest} from './end_session_request';\nimport {EndSessionResponse} from './end_session_response';\nimport {log} from './logger';\nimport {BasicQueryStringUtils} from './query_string_utils';\nimport {LocalStorageBackend, StorageBackend} from './storage';\nimport {LocationLike, RedirectRequestTypes} from './types';\n\n\n/** key for authorization request. */\nconst requestKey =\n    (handle: string, requestType: RedirectRequestTypes) => {\n      return `${handle}_appauth_${requestType}_request`;\n    }\n\n/** key for authorization service configuration */\nconst serviceConfigurationKey =\n    (handle: string, requestType: RedirectRequestTypes) => {\n      return `${handle}_appauth_${requestType}_service_configuration`;\n    }\n\n/** key in local storage which represents the current authorization request. */\nconst REQUEST_HANDLE_KEY = (requestType: RedirectRequestTypes) =>\n    `appauth_current_${requestType}_request`;\n\n/**\n * Represents an AuthorizationRequestHandler which uses a standard\n * redirect based code flow.\n */\nexport class RedirectRequestHandler extends AuthorizationRequestHandler {\n  constructor(\n      // use the provided storage backend\n      // or initialize local storage with the default storage backend which\n      // uses window.localStorage\n      public storageBackend: StorageBackend = new LocalStorageBackend(),\n      utils = new BasicQueryStringUtils(),\n      public locationLike: LocationLike = window.location,\n      crypto: Crypto = new DefaultCrypto()) {\n    super(utils, crypto);\n  }\n\n  performAuthorizationRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationRequest) {\n    this.performRequest(configuration, request, RedirectRequestTypes.authorization);\n  }\n\n  performEndSessionRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: EndSessionRequest) {\n    this.performRequest(configuration, request, RedirectRequestTypes.endSession);\n  }\n\n  private performRequest(\n      configuration: AuthorizationServiceConfiguration,\n      request: AuthorizationManagementRequest,\n      requestType: RedirectRequestTypes = RedirectRequestTypes.authorization) {\n    const handle = this.crypto.generateRandom(10);\n\n    // before you make request, persist all request related data in local storage.\n    const persisted = Promise.all([\n      this.storageBackend.setItem(REQUEST_HANDLE_KEY(requestType), handle),\n      // Calling toJson() adds in the code & challenge when possible\n      request.toJson().then(\n          result =>\n              this.storageBackend.setItem(requestKey(handle, requestType), JSON.stringify(result))),\n      this.storageBackend.setItem(\n          serviceConfigurationKey(handle, requestType), JSON.stringify(configuration.toJson())),\n    ]);\n\n    persisted.then(() => {\n      // make the redirect request\n      let url = this.buildRequestUrl(configuration, request, requestType);\n      log('Making a request to ', request, url);\n      this.locationLike.assign(url);\n    });\n  }\n\n  /**\n   * Attempts to introspect the contents of storage backend and completes the\n   *  authorization request.\n   */\n  protected completeAuthorizationRequest(): Promise<AuthorizationRequestResponse|null> {\n    return this.completeRequest(RedirectRequestTypes.authorization);\n  }\n\n  /**\n   * Attempts to introspect the contents of storage backend and completes the\n   * end session request.\n   */\n  protected completeEndSessionRequest(): Promise<AuthorizationRequestResponse|null> {\n    return this.completeRequest(RedirectRequestTypes.endSession);\n  }\n\n  /**\n   * Attempts to introspect the contents of storage backend and completes the\n   * request.\n   */\n  private completeRequest(requestType: RedirectRequestTypes) {\n    // TODO(rahulrav@): handle authorization errors.\n    return this.storageBackend.getItem(REQUEST_HANDLE_KEY(requestType)).then(handle => {\n      if (handle) {\n        // we have a pending request.\n        // fetch authorization request, and check state\n        return this.storageBackend\n            .getItem(requestKey(handle, requestType))\n            // requires a corresponding instance of result\n            // TODO(rahulrav@): check for inconsistent state here\n            .then(result => JSON.parse(result!))\n            .then(\n                json => requestType === RedirectRequestTypes.authorization ?\n                    new AuthorizationRequest(json) :\n                    new EndSessionRequest(json))\n            .then(request => {\n              // check redirect_uri and state\n              let currentUri = `${this.locationLike.origin}${this.locationLike.pathname}`;\n              let queryParams = this.utils.parse(this.locationLike, true /* use hash */);\n              let state: string|undefined = queryParams['state'];\n              let code: string|undefined = queryParams['code'];\n              let error: string|undefined = queryParams['error'];\n              if (requestType === RedirectRequestTypes.authorization) {\n                log('Potential authorization request ',\n                    currentUri,\n                    queryParams,\n                    state,\n                    code,\n                    error);\n              } else {\n                log('Potential end session request ', currentUri, queryParams, state, error)\n              }\n              let shouldNotify = state === request.state;\n              let authorizationResponse: EndSessionResponse|AuthorizationResponse|null = null;\n              let authorizationError: AuthorizationError|null = null;\n              if (shouldNotify) {\n                if (error) {\n                  // get additional optional info.\n                  let errorUri = queryParams['error_uri'];\n                  let errorDescription = queryParams['error_description'];\n                  authorizationError = new AuthorizationError({\n                    error: error,\n                    error_description: errorDescription,\n                    error_uri: errorUri,\n                    state: state\n                  });\n                } else {\n                  if (requestType === RedirectRequestTypes.authorization) {\n                    authorizationResponse = new AuthorizationResponse({code: code, state: state});\n                  } else if (requestType === RedirectRequestTypes.endSession) {\n                    authorizationResponse = new EndSessionResponse({state: state})\n                  }\n                }\n                // cleanup state\n                return Promise\n                    .all([\n                      this.storageBackend.removeItem(REQUEST_HANDLE_KEY(requestType)),\n                      this.storageBackend.removeItem(requestKey(handle, requestType)),\n                      this.storageBackend.removeItem(serviceConfigurationKey(handle, requestType))\n                    ])\n                    .then(() => {\n                      log('Delivering authorization response');\n                      return {\n                        request: request,\n                        response: authorizationResponse,\n                        error: authorizationError\n                      } as AuthorizationRequestResponse;\n                    });\n              } else {\n                log('Mismatched request (state and request_uri) dont match.');\n                return Promise.resolve(null);\n              }\n            });\n      } else {\n        return null;\n      }\n    });\n  }\n}\n"]} \ No newline at end of file diff --git a/built/types.d.ts b/built/types.d.ts index 78565a9..cc8ab5e 100644 --- a/built/types.d.ts +++ b/built/types.d.ts @@ -15,3 +15,7 @@ export interface LocationLike { search: string; assign(url: string): void; } +export declare enum RedirectRequestTypes { + endSession = "end_session", + authorization = "authorization" +} diff --git a/built/types.js b/built/types.js index d6cbfda..d5a21bd 100644 --- a/built/types.js +++ b/built/types.js @@ -13,4 +13,10 @@ * limitations under the License. */ Object.defineProperty(exports, "__esModule", { value: true }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7Ozs7Ozs7R0FZRyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNyBHb29nbGUgSW5jLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7IHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0XG4gKiBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlXG4gKiBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUywgV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlclxuICogZXhwcmVzcyBvciBpbXBsaWVkLiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgaW50ZXJmYWNlIFN0cmluZ01hcCB7XG4gIFtrZXk6IHN0cmluZ106IHN0cmluZztcbn1cblxuLyoqXG4gKiBSZXByZXNlbnRzIGEgd2luZG93LmxvY2F0aW9uIGxpa2Ugb2JqZWN0LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIExvY2F0aW9uTGlrZSB7XG4gIGhhc2g6IHN0cmluZztcbiAgaG9zdDogc3RyaW5nO1xuICBvcmlnaW46IHN0cmluZztcbiAgaG9zdG5hbWU6IHN0cmluZztcbiAgcGF0aG5hbWU6IHN0cmluZztcbiAgcG9ydDogc3RyaW5nO1xuICBwcm90b2NvbDogc3RyaW5nO1xuICBzZWFyY2g6IHN0cmluZztcbiAgYXNzaWduKHVybDogc3RyaW5nKTogdm9pZDtcbn1cbiJdfQ== \ No newline at end of file +exports.RedirectRequestTypes = void 0; +var RedirectRequestTypes; +(function (RedirectRequestTypes) { + RedirectRequestTypes["endSession"] = "end_session"; + RedirectRequestTypes["authorization"] = "authorization"; +})(RedirectRequestTypes = exports.RedirectRequestTypes || (exports.RedirectRequestTypes = {})); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7Ozs7Ozs7R0FZRzs7O0FBcUJILElBQVksb0JBR1g7QUFIRCxXQUFZLG9CQUFvQjtJQUM5QixrREFBMEIsQ0FBQTtJQUMxQix1REFBK0IsQ0FBQTtBQUNqQyxDQUFDLEVBSFcsb0JBQW9CLEdBQXBCLDRCQUFvQixLQUFwQiw0QkFBb0IsUUFHL0IiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTcgR29vZ2xlIEluYy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpOyB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdFxuICogaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZVxuICogTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXJcbiAqIGV4cHJlc3Mgb3IgaW1wbGllZC4gU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0IGludGVyZmFjZSBTdHJpbmdNYXAge1xuICBba2V5OiBzdHJpbmddOiBzdHJpbmc7XG59XG5cbi8qKlxuICogUmVwcmVzZW50cyBhIHdpbmRvdy5sb2NhdGlvbiBsaWtlIG9iamVjdC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBMb2NhdGlvbkxpa2Uge1xuICBoYXNoOiBzdHJpbmc7XG4gIGhvc3Q6IHN0cmluZztcbiAgb3JpZ2luOiBzdHJpbmc7XG4gIGhvc3RuYW1lOiBzdHJpbmc7XG4gIHBhdGhuYW1lOiBzdHJpbmc7XG4gIHBvcnQ6IHN0cmluZztcbiAgcHJvdG9jb2w6IHN0cmluZztcbiAgc2VhcmNoOiBzdHJpbmc7XG4gIGFzc2lnbih1cmw6IHN0cmluZyk6IHZvaWQ7XG59XG5cbmV4cG9ydCBlbnVtIFJlZGlyZWN0UmVxdWVzdFR5cGVzIHtcbiAgZW5kU2Vzc2lvbiA9ICdlbmRfc2Vzc2lvbicsXG4gIGF1dGhvcml6YXRpb24gPSAnYXV0aG9yaXphdGlvbidcbn0iXX0= \ No newline at end of file From 0f012ce849be01621a0037f4b25ecd11262ef992 Mon Sep 17 00:00:00 2001 From: Arsalan Salari Date: Sat, 11 Sep 2021 19:09:20 +0430 Subject: [PATCH 12/13] Add readme for end session --- README.md | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/README.md b/README.md index fbef7c0..90663c4 100644 --- a/README.md +++ b/README.md @@ -113,6 +113,33 @@ this.tokenHandler.performTokenRequest(this.configuration, request) }); ``` +##### Make End Session Requests + +```typescript +this.notifier = new AuthorizationNotifier(); +// uses a redirect flow +this.authorizationHandler = new RedirectRequestHandler(); +// set notifier to deliver responses +this.authorizationHandler.setAuthorizationNotifier(this.notifier); +// set a listener to listen for authorization responses +this.notifier.setAuthorizationListener((request, response, error) => { + log('End Session request complete ', request, response, error); + if (response && response instanceof EndSessionResponse) { + //do clean up + } +}); + +// create a request +const request = new EndSessionRequest({ + id_token_hint: this.tokenResponse?.idToken, + post_logout_redirect_uri: settings.post_logout_redirect_uri, + state: undefined, + }) + +// make the end Session request +this.authorizationHandler.performEndSessionRequest(this.configuration, request); +``` + ### Development #### Preamble From fc9125892c361a9e9445e941bc7395ef06e9ff05 Mon Sep 17 00:00:00 2001 From: Arsalan Salari Date: Sat, 11 Sep 2021 19:11:25 +0430 Subject: [PATCH 13/13] Fix readme --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 90663c4..dfc524b 100644 --- a/README.md +++ b/README.md @@ -131,8 +131,8 @@ this.notifier.setAuthorizationListener((request, response, error) => { // create a request const request = new EndSessionRequest({ - id_token_hint: this.tokenResponse?.idToken, - post_logout_redirect_uri: settings.post_logout_redirect_uri, + id_token_hint: idToken, + post_logout_redirect_uri: post_logout_redirect_uri, state: undefined, })