6329 lines
855 KiB
JavaScript
6329 lines
855 KiB
JavaScript
/*! @azure/msal-common v4.0.1 2021-02-18 */
|
||
'use strict';
|
||
/*! *****************************************************************************
|
||
Copyright (c) Microsoft Corporation.
|
||
|
||
Permission to use, copy, modify, and/or distribute this software for any
|
||
purpose with or without fee is hereby granted.
|
||
|
||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
||
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
||
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
||
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||
PERFORMANCE OF THIS SOFTWARE.
|
||
***************************************************************************** */
|
||
/* global Reflect, Promise */
|
||
|
||
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);
|
||
};
|
||
|
||
function __extends(d, b) {
|
||
extendStatics(d, b);
|
||
function __() { this.constructor = d; }
|
||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||
}
|
||
|
||
var __assign = function() {
|
||
__assign = Object.assign || function __assign(t) {
|
||
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
||
s = arguments[i];
|
||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
|
||
}
|
||
return t;
|
||
};
|
||
return __assign.apply(this, arguments);
|
||
};
|
||
|
||
function __awaiter(thisArg, _arguments, P, generator) {
|
||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
}
|
||
|
||
function __generator(thisArg, body) {
|
||
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
||
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
||
function verb(n) { return function (v) { return step([n, v]); }; }
|
||
function step(op) {
|
||
if (f) throw new TypeError("Generator is already executing.");
|
||
while (_) try {
|
||
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
||
if (y = 0, t) op = [op[0] & 2, t.value];
|
||
switch (op[0]) {
|
||
case 0: case 1: t = op; break;
|
||
case 4: _.label++; return { value: op[1], done: false };
|
||
case 5: _.label++; y = op[1]; op = [0]; continue;
|
||
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
||
default:
|
||
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
||
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
||
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
||
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
||
if (t[2]) _.ops.pop();
|
||
_.trys.pop(); continue;
|
||
}
|
||
op = body.call(thisArg, _);
|
||
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
||
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
||
}
|
||
}
|
||
|
||
function __spreadArrays() {
|
||
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
|
||
for (var r = Array(s), k = 0, i = 0; i < il; i++)
|
||
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
|
||
r[k] = a[j];
|
||
return r;
|
||
}
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var Constants = {
|
||
LIBRARY_NAME: "MSAL.JS",
|
||
SKU: "msal.js.common",
|
||
// Prefix for all library cache entries
|
||
CACHE_PREFIX: "msal",
|
||
// default authority
|
||
DEFAULT_AUTHORITY: "https://login.microsoftonline.com/common/",
|
||
DEFAULT_AUTHORITY_HOST: "login.microsoftonline.com",
|
||
// ADFS String
|
||
ADFS: "adfs",
|
||
// Default AAD Instance Discovery Endpoint
|
||
AAD_INSTANCE_DISCOVERY_ENDPT: "https://login.microsoftonline.com/common/discovery/instance?api-version=1.1&authorization_endpoint=",
|
||
// Resource delimiter - used for certain cache entries
|
||
RESOURCE_DELIM: "|",
|
||
// Placeholder for non-existent account ids/objects
|
||
NO_ACCOUNT: "NO_ACCOUNT",
|
||
// Claims
|
||
CLAIMS: "claims",
|
||
// Consumer UTID
|
||
CONSUMER_UTID: "9188040d-6c67-4c5b-b112-36a304b66dad",
|
||
// Default scopes
|
||
OPENID_SCOPE: "openid",
|
||
PROFILE_SCOPE: "profile",
|
||
OFFLINE_ACCESS_SCOPE: "offline_access",
|
||
EMAIL_SCOPE: "email",
|
||
// Default response type for authorization code flow
|
||
CODE_RESPONSE_TYPE: "code",
|
||
CODE_GRANT_TYPE: "authorization_code",
|
||
RT_GRANT_TYPE: "refresh_token",
|
||
FRAGMENT_RESPONSE_MODE: "fragment",
|
||
S256_CODE_CHALLENGE_METHOD: "S256",
|
||
URL_FORM_CONTENT_TYPE: "application/x-www-form-urlencoded;charset=utf-8",
|
||
AUTHORIZATION_PENDING: "authorization_pending",
|
||
NOT_DEFINED: "not_defined",
|
||
EMPTY_STRING: "",
|
||
FORWARD_SLASH: "/"
|
||
};
|
||
var OIDC_DEFAULT_SCOPES = [
|
||
Constants.OPENID_SCOPE,
|
||
Constants.PROFILE_SCOPE,
|
||
Constants.OFFLINE_ACCESS_SCOPE
|
||
];
|
||
var OIDC_SCOPES = __spreadArrays(OIDC_DEFAULT_SCOPES, [
|
||
Constants.EMAIL_SCOPE
|
||
]);
|
||
/**
|
||
* Request header names
|
||
*/
|
||
var HeaderNames;
|
||
(function (HeaderNames) {
|
||
HeaderNames["CONTENT_TYPE"] = "Content-Type";
|
||
HeaderNames["X_CLIENT_CURR_TELEM"] = "x-client-current-telemetry";
|
||
HeaderNames["X_CLIENT_LAST_TELEM"] = "x-client-last-telemetry";
|
||
HeaderNames["RETRY_AFTER"] = "Retry-After";
|
||
HeaderNames["X_MS_LIB_CAPABILITY"] = "x-ms-lib-capability";
|
||
HeaderNames["X_MS_LIB_CAPABILITY_VALUE"] = "retry-after, h429";
|
||
})(HeaderNames || (HeaderNames = {}));
|
||
/**
|
||
* Persistent cache keys MSAL which stay while user is logged in.
|
||
*/
|
||
var PersistentCacheKeys;
|
||
(function (PersistentCacheKeys) {
|
||
PersistentCacheKeys["ID_TOKEN"] = "idtoken";
|
||
PersistentCacheKeys["CLIENT_INFO"] = "client.info";
|
||
PersistentCacheKeys["ADAL_ID_TOKEN"] = "adal.idtoken";
|
||
PersistentCacheKeys["ERROR"] = "error";
|
||
PersistentCacheKeys["ERROR_DESC"] = "error.description";
|
||
})(PersistentCacheKeys || (PersistentCacheKeys = {}));
|
||
/**
|
||
* String constants related to AAD Authority
|
||
*/
|
||
var AADAuthorityConstants;
|
||
(function (AADAuthorityConstants) {
|
||
AADAuthorityConstants["COMMON"] = "common";
|
||
AADAuthorityConstants["ORGANIZATIONS"] = "organizations";
|
||
AADAuthorityConstants["CONSUMERS"] = "consumers";
|
||
})(AADAuthorityConstants || (AADAuthorityConstants = {}));
|
||
/**
|
||
* Keys in the hashParams sent by AAD Server
|
||
*/
|
||
var AADServerParamKeys;
|
||
(function (AADServerParamKeys) {
|
||
AADServerParamKeys["CLIENT_ID"] = "client_id";
|
||
AADServerParamKeys["REDIRECT_URI"] = "redirect_uri";
|
||
AADServerParamKeys["RESPONSE_TYPE"] = "response_type";
|
||
AADServerParamKeys["RESPONSE_MODE"] = "response_mode";
|
||
AADServerParamKeys["GRANT_TYPE"] = "grant_type";
|
||
AADServerParamKeys["CLAIMS"] = "claims";
|
||
AADServerParamKeys["SCOPE"] = "scope";
|
||
AADServerParamKeys["ERROR"] = "error";
|
||
AADServerParamKeys["ERROR_DESCRIPTION"] = "error_description";
|
||
AADServerParamKeys["ACCESS_TOKEN"] = "access_token";
|
||
AADServerParamKeys["ID_TOKEN"] = "id_token";
|
||
AADServerParamKeys["REFRESH_TOKEN"] = "refresh_token";
|
||
AADServerParamKeys["EXPIRES_IN"] = "expires_in";
|
||
AADServerParamKeys["STATE"] = "state";
|
||
AADServerParamKeys["NONCE"] = "nonce";
|
||
AADServerParamKeys["PROMPT"] = "prompt";
|
||
AADServerParamKeys["SESSION_STATE"] = "session_state";
|
||
AADServerParamKeys["CLIENT_INFO"] = "client_info";
|
||
AADServerParamKeys["CODE"] = "code";
|
||
AADServerParamKeys["CODE_CHALLENGE"] = "code_challenge";
|
||
AADServerParamKeys["CODE_CHALLENGE_METHOD"] = "code_challenge_method";
|
||
AADServerParamKeys["CODE_VERIFIER"] = "code_verifier";
|
||
AADServerParamKeys["CLIENT_REQUEST_ID"] = "client-request-id";
|
||
AADServerParamKeys["X_CLIENT_SKU"] = "x-client-SKU";
|
||
AADServerParamKeys["X_CLIENT_VER"] = "x-client-VER";
|
||
AADServerParamKeys["X_CLIENT_OS"] = "x-client-OS";
|
||
AADServerParamKeys["X_CLIENT_CPU"] = "x-client-CPU";
|
||
AADServerParamKeys["POST_LOGOUT_URI"] = "post_logout_redirect_uri";
|
||
AADServerParamKeys["ID_TOKEN_HINT"] = "id_token_hint";
|
||
AADServerParamKeys["DEVICE_CODE"] = "device_code";
|
||
AADServerParamKeys["CLIENT_SECRET"] = "client_secret";
|
||
AADServerParamKeys["CLIENT_ASSERTION"] = "client_assertion";
|
||
AADServerParamKeys["CLIENT_ASSERTION_TYPE"] = "client_assertion_type";
|
||
AADServerParamKeys["TOKEN_TYPE"] = "token_type";
|
||
AADServerParamKeys["REQ_CNF"] = "req_cnf";
|
||
AADServerParamKeys["OBO_ASSERTION"] = "assertion";
|
||
AADServerParamKeys["REQUESTED_TOKEN_USE"] = "requested_token_use";
|
||
AADServerParamKeys["ON_BEHALF_OF"] = "on_behalf_of";
|
||
AADServerParamKeys["FOCI"] = "foci";
|
||
})(AADServerParamKeys || (AADServerParamKeys = {}));
|
||
/**
|
||
* Claims request keys
|
||
*/
|
||
var ClaimsRequestKeys;
|
||
(function (ClaimsRequestKeys) {
|
||
ClaimsRequestKeys["ACCESS_TOKEN"] = "access_token";
|
||
ClaimsRequestKeys["XMS_CC"] = "xms_cc";
|
||
})(ClaimsRequestKeys || (ClaimsRequestKeys = {}));
|
||
/**
|
||
* we considered making this "enum" in the request instead of string, however it looks like the allowed list of
|
||
* prompt values kept changing over past couple of years. There are some undocumented prompt values for some
|
||
* internal partners too, hence the choice of generic "string" type instead of the "enum"
|
||
*/
|
||
var PromptValue = {
|
||
LOGIN: "login",
|
||
SELECT_ACCOUNT: "select_account",
|
||
CONSENT: "consent",
|
||
NONE: "none",
|
||
};
|
||
/**
|
||
* SSO Types - generated to populate hints
|
||
*/
|
||
var SSOTypes;
|
||
(function (SSOTypes) {
|
||
SSOTypes["ACCOUNT"] = "account";
|
||
SSOTypes["SID"] = "sid";
|
||
SSOTypes["LOGIN_HINT"] = "login_hint";
|
||
SSOTypes["ID_TOKEN"] = "id_token";
|
||
SSOTypes["DOMAIN_HINT"] = "domain_hint";
|
||
SSOTypes["ORGANIZATIONS"] = "organizations";
|
||
SSOTypes["CONSUMERS"] = "consumers";
|
||
SSOTypes["ACCOUNT_ID"] = "accountIdentifier";
|
||
SSOTypes["HOMEACCOUNT_ID"] = "homeAccountIdentifier";
|
||
})(SSOTypes || (SSOTypes = {}));
|
||
/**
|
||
* Disallowed extra query parameters.
|
||
*/
|
||
var BlacklistedEQParams = [
|
||
SSOTypes.SID,
|
||
SSOTypes.LOGIN_HINT
|
||
];
|
||
/**
|
||
* allowed values for codeVerifier
|
||
*/
|
||
var CodeChallengeMethodValues = {
|
||
PLAIN: "plain",
|
||
S256: "S256"
|
||
};
|
||
/**
|
||
* allowed values for response_mode
|
||
*/
|
||
var ResponseMode;
|
||
(function (ResponseMode) {
|
||
ResponseMode["QUERY"] = "query";
|
||
ResponseMode["FRAGMENT"] = "fragment";
|
||
ResponseMode["FORM_POST"] = "form_post";
|
||
})(ResponseMode || (ResponseMode = {}));
|
||
/**
|
||
* allowed grant_type
|
||
*/
|
||
var GrantType;
|
||
(function (GrantType) {
|
||
GrantType["IMPLICIT_GRANT"] = "implicit";
|
||
GrantType["AUTHORIZATION_CODE_GRANT"] = "authorization_code";
|
||
GrantType["CLIENT_CREDENTIALS_GRANT"] = "client_credentials";
|
||
GrantType["RESOURCE_OWNER_PASSWORD_GRANT"] = "password";
|
||
GrantType["REFRESH_TOKEN_GRANT"] = "refresh_token";
|
||
GrantType["DEVICE_CODE_GRANT"] = "device_code";
|
||
GrantType["JWT_BEARER"] = "urn:ietf:params:oauth:grant-type:jwt-bearer";
|
||
})(GrantType || (GrantType = {}));
|
||
/**
|
||
* Account types in Cache
|
||
*/
|
||
var CacheAccountType;
|
||
(function (CacheAccountType) {
|
||
CacheAccountType["MSSTS_ACCOUNT_TYPE"] = "MSSTS";
|
||
CacheAccountType["ADFS_ACCOUNT_TYPE"] = "ADFS";
|
||
CacheAccountType["MSAV1_ACCOUNT_TYPE"] = "MSA";
|
||
CacheAccountType["GENERIC_ACCOUNT_TYPE"] = "Generic"; // NTLM, Kerberos, FBA, Basic etc
|
||
})(CacheAccountType || (CacheAccountType = {}));
|
||
/**
|
||
* Separators used in cache
|
||
*/
|
||
var Separators;
|
||
(function (Separators) {
|
||
Separators["CACHE_KEY_SEPARATOR"] = "-";
|
||
Separators["CLIENT_INFO_SEPARATOR"] = ".";
|
||
})(Separators || (Separators = {}));
|
||
/**
|
||
* Credential Type stored in the cache
|
||
*/
|
||
var CredentialType;
|
||
(function (CredentialType) {
|
||
CredentialType["ID_TOKEN"] = "IdToken";
|
||
CredentialType["ACCESS_TOKEN"] = "AccessToken";
|
||
CredentialType["REFRESH_TOKEN"] = "RefreshToken";
|
||
})(CredentialType || (CredentialType = {}));
|
||
/**
|
||
* Credential Type stored in the cache
|
||
*/
|
||
var CacheSchemaType;
|
||
(function (CacheSchemaType) {
|
||
CacheSchemaType["ACCOUNT"] = "Account";
|
||
CacheSchemaType["CREDENTIAL"] = "Credential";
|
||
CacheSchemaType["ID_TOKEN"] = "IdToken";
|
||
CacheSchemaType["ACCESS_TOKEN"] = "AccessToken";
|
||
CacheSchemaType["REFRESH_TOKEN"] = "RefreshToken";
|
||
CacheSchemaType["APP_METADATA"] = "AppMetadata";
|
||
CacheSchemaType["TEMPORARY"] = "TempCache";
|
||
CacheSchemaType["TELEMETRY"] = "Telemetry";
|
||
CacheSchemaType["UNDEFINED"] = "Undefined";
|
||
CacheSchemaType["THROTTLING"] = "Throttling";
|
||
})(CacheSchemaType || (CacheSchemaType = {}));
|
||
/**
|
||
* Combine all cache types
|
||
*/
|
||
var CacheType;
|
||
(function (CacheType) {
|
||
CacheType[CacheType["ADFS"] = 1001] = "ADFS";
|
||
CacheType[CacheType["MSA"] = 1002] = "MSA";
|
||
CacheType[CacheType["MSSTS"] = 1003] = "MSSTS";
|
||
CacheType[CacheType["GENERIC"] = 1004] = "GENERIC";
|
||
CacheType[CacheType["ACCESS_TOKEN"] = 2001] = "ACCESS_TOKEN";
|
||
CacheType[CacheType["REFRESH_TOKEN"] = 2002] = "REFRESH_TOKEN";
|
||
CacheType[CacheType["ID_TOKEN"] = 2003] = "ID_TOKEN";
|
||
CacheType[CacheType["APP_METADATA"] = 3001] = "APP_METADATA";
|
||
CacheType[CacheType["UNDEFINED"] = 9999] = "UNDEFINED";
|
||
})(CacheType || (CacheType = {}));
|
||
/**
|
||
* More Cache related constants
|
||
*/
|
||
var APP_METADATA = "appmetadata";
|
||
var ClientInfo = "client_info";
|
||
var THE_FAMILY_ID = "1";
|
||
var AUTHORITY_METADATA_CONSTANTS = {
|
||
CACHE_KEY: "authority-metadata",
|
||
REFRESH_TIME_SECONDS: 3600 * 24 // 24 Hours
|
||
};
|
||
var AuthorityMetadataSource;
|
||
(function (AuthorityMetadataSource) {
|
||
AuthorityMetadataSource["CONFIG"] = "config";
|
||
AuthorityMetadataSource["CACHE"] = "cache";
|
||
AuthorityMetadataSource["NETWORK"] = "network";
|
||
})(AuthorityMetadataSource || (AuthorityMetadataSource = {}));
|
||
var SERVER_TELEM_CONSTANTS = {
|
||
SCHEMA_VERSION: 2,
|
||
MAX_HEADER_BYTES: 4000,
|
||
CACHE_KEY: "server-telemetry",
|
||
CATEGORY_SEPARATOR: "|",
|
||
VALUE_SEPARATOR: ",",
|
||
OVERFLOW_TRUE: "1",
|
||
OVERFLOW_FALSE: "0",
|
||
UNKNOWN_ERROR: "unknown_error"
|
||
};
|
||
/**
|
||
* Type of the authentication request
|
||
*/
|
||
var AuthenticationScheme;
|
||
(function (AuthenticationScheme) {
|
||
AuthenticationScheme["POP"] = "pop";
|
||
AuthenticationScheme["BEARER"] = "Bearer";
|
||
})(AuthenticationScheme || (AuthenticationScheme = {}));
|
||
/**
|
||
* Constants related to throttling
|
||
*/
|
||
var ThrottlingConstants = {
|
||
// Default time to throttle RequestThumbprint in seconds
|
||
DEFAULT_THROTTLE_TIME_SECONDS: 60,
|
||
// Default maximum time to throttle in seconds, overrides what the server sends back
|
||
DEFAULT_MAX_THROTTLE_TIME_SECONDS: 3600,
|
||
// Prefix for storing throttling entries
|
||
THROTTLING_PREFIX: "throttling"
|
||
};
|
||
var Errors = {
|
||
INVALID_GRANT_ERROR: "invalid_grant",
|
||
CLIENT_MISMATCH_ERROR: "client_mismatch",
|
||
};
|
||
/**
|
||
* Password grant parameters
|
||
*/
|
||
var PasswordGrantConstants;
|
||
(function (PasswordGrantConstants) {
|
||
PasswordGrantConstants["username"] = "username";
|
||
PasswordGrantConstants["password"] = "password";
|
||
})(PasswordGrantConstants || (PasswordGrantConstants = {}));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* AuthErrorMessage class containing string constants used by error codes and messages.
|
||
*/
|
||
var AuthErrorMessage = {
|
||
unexpectedError: {
|
||
code: "unexpected_error",
|
||
desc: "Unexpected error in authentication."
|
||
}
|
||
};
|
||
/**
|
||
* General error class thrown by the MSAL.js library.
|
||
*/
|
||
var AuthError = /** @class */ (function (_super) {
|
||
__extends(AuthError, _super);
|
||
function AuthError(errorCode, errorMessage, suberror) {
|
||
var _this = this;
|
||
var errorString = errorMessage ? errorCode + ": " + errorMessage : errorCode;
|
||
_this = _super.call(this, errorString) || this;
|
||
Object.setPrototypeOf(_this, AuthError.prototype);
|
||
_this.errorCode = errorCode || Constants.EMPTY_STRING;
|
||
_this.errorMessage = errorMessage || "";
|
||
_this.subError = suberror || "";
|
||
_this.name = "AuthError";
|
||
return _this;
|
||
}
|
||
/**
|
||
* Creates an error that is thrown when something unexpected happens in the library.
|
||
* @param errDesc
|
||
*/
|
||
AuthError.createUnexpectedError = function (errDesc) {
|
||
return new AuthError(AuthErrorMessage.unexpectedError.code, AuthErrorMessage.unexpectedError.desc + ": " + errDesc);
|
||
};
|
||
return AuthError;
|
||
}(Error));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var DEFAULT_CRYPTO_IMPLEMENTATION = {
|
||
createNewGuid: function () {
|
||
var notImplErr = "Crypto interface - createNewGuid() has not been implemented";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
},
|
||
base64Decode: function () {
|
||
var notImplErr = "Crypto interface - base64Decode() has not been implemented";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
},
|
||
base64Encode: function () {
|
||
var notImplErr = "Crypto interface - base64Encode() has not been implemented";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
},
|
||
generatePkceCodes: function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var notImplErr;
|
||
return __generator(this, function (_a) {
|
||
notImplErr = "Crypto interface - generatePkceCodes() has not been implemented";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
});
|
||
});
|
||
},
|
||
getPublicKeyThumbprint: function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var notImplErr;
|
||
return __generator(this, function (_a) {
|
||
notImplErr = "Crypto interface - getPublicKeyThumbprint() has not been implemented";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
});
|
||
});
|
||
},
|
||
signJwt: function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var notImplErr;
|
||
return __generator(this, function (_a) {
|
||
notImplErr = "Crypto interface - signJwt() has not been implemented";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
});
|
||
});
|
||
}
|
||
};
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* ClientAuthErrorMessage class containing string constants used by error codes and messages.
|
||
*/
|
||
var ClientAuthErrorMessage = {
|
||
clientInfoDecodingError: {
|
||
code: "client_info_decoding_error",
|
||
desc: "The client info could not be parsed/decoded correctly. Please review the trace to determine the root cause."
|
||
},
|
||
clientInfoEmptyError: {
|
||
code: "client_info_empty_error",
|
||
desc: "The client info was empty. Please review the trace to determine the root cause."
|
||
},
|
||
tokenParsingError: {
|
||
code: "token_parsing_error",
|
||
desc: "Token cannot be parsed. Please review stack trace to determine root cause."
|
||
},
|
||
nullOrEmptyToken: {
|
||
code: "null_or_empty_token",
|
||
desc: "The token is null or empty. Please review the trace to determine the root cause."
|
||
},
|
||
endpointResolutionError: {
|
||
code: "endpoints_resolution_error",
|
||
desc: "Error: could not resolve endpoints. Please check network and try again."
|
||
},
|
||
unableToGetOpenidConfigError: {
|
||
code: "openid_config_error",
|
||
desc: "Could not retrieve endpoints. Check your authority and verify the .well-known/openid-configuration endpoint returns the required endpoints."
|
||
},
|
||
hashNotDeserialized: {
|
||
code: "hash_not_deserialized",
|
||
desc: "The hash parameters could not be deserialized. Please review the trace to determine the root cause."
|
||
},
|
||
blankGuidGenerated: {
|
||
code: "blank_guid_generated",
|
||
desc: "The guid generated was blank. Please review the trace to determine the root cause."
|
||
},
|
||
invalidStateError: {
|
||
code: "invalid_state",
|
||
desc: "State was not the expected format. Please check the logs to determine whether the request was sent using ProtocolUtils.setRequestState()."
|
||
},
|
||
stateMismatchError: {
|
||
code: "state_mismatch",
|
||
desc: "State mismatch error. Please check your network. Continued requests may cause cache overflow."
|
||
},
|
||
stateNotFoundError: {
|
||
code: "state_not_found",
|
||
desc: "State not found"
|
||
},
|
||
nonceMismatchError: {
|
||
code: "nonce_mismatch",
|
||
desc: "Nonce mismatch error. This may be caused by a race condition in concurrent requests."
|
||
},
|
||
nonceNotFoundError: {
|
||
code: "nonce_not_found",
|
||
desc: "nonce not found"
|
||
},
|
||
noTokensFoundError: {
|
||
code: "no_tokens_found",
|
||
desc: "No tokens were found for the given scopes, and no authorization code was passed to acquireToken. You must retrieve an authorization code before making a call to acquireToken()."
|
||
},
|
||
multipleMatchingTokens: {
|
||
code: "multiple_matching_tokens",
|
||
desc: "The cache contains multiple tokens satisfying the requirements. " +
|
||
"Call AcquireToken again providing more requirements such as authority or account."
|
||
},
|
||
multipleMatchingAccounts: {
|
||
code: "multiple_matching_accounts",
|
||
desc: "The cache contains multiple accounts satisfying the given parameters. Please pass more info to obtain the correct account"
|
||
},
|
||
multipleMatchingAppMetadata: {
|
||
code: "multiple_matching_appMetadata",
|
||
desc: "The cache contains multiple appMetadata satisfying the given parameters. Please pass more info to obtain the correct appMetadata"
|
||
},
|
||
tokenRequestCannotBeMade: {
|
||
code: "request_cannot_be_made",
|
||
desc: "Token request cannot be made without authorization code or refresh token."
|
||
},
|
||
appendEmptyScopeError: {
|
||
code: "cannot_append_empty_scope",
|
||
desc: "Cannot append null or empty scope to ScopeSet. Please check the stack trace for more info."
|
||
},
|
||
removeEmptyScopeError: {
|
||
code: "cannot_remove_empty_scope",
|
||
desc: "Cannot remove null or empty scope from ScopeSet. Please check the stack trace for more info."
|
||
},
|
||
appendScopeSetError: {
|
||
code: "cannot_append_scopeset",
|
||
desc: "Cannot append ScopeSet due to error."
|
||
},
|
||
emptyInputScopeSetError: {
|
||
code: "empty_input_scopeset",
|
||
desc: "Empty input ScopeSet cannot be processed."
|
||
},
|
||
DeviceCodePollingCancelled: {
|
||
code: "device_code_polling_cancelled",
|
||
desc: "Caller has cancelled token endpoint polling during device code flow by setting DeviceCodeRequest.cancel = true."
|
||
},
|
||
DeviceCodeExpired: {
|
||
code: "device_code_expired",
|
||
desc: "Device code is expired."
|
||
},
|
||
NoAccountInSilentRequest: {
|
||
code: "no_account_in_silent_request",
|
||
desc: "Please pass an account object, silent flow is not supported without account information"
|
||
},
|
||
invalidCacheRecord: {
|
||
code: "invalid_cache_record",
|
||
desc: "Cache record object was null or undefined."
|
||
},
|
||
invalidCacheEnvironment: {
|
||
code: "invalid_cache_environment",
|
||
desc: "Invalid environment when attempting to create cache entry"
|
||
},
|
||
noAccountFound: {
|
||
code: "no_account_found",
|
||
desc: "No account found in cache for given key."
|
||
},
|
||
CachePluginError: {
|
||
code: "no cache plugin set on CacheManager",
|
||
desc: "ICachePlugin needs to be set before using readFromStorage or writeFromStorage"
|
||
},
|
||
noCryptoObj: {
|
||
code: "no_crypto_object",
|
||
desc: "No crypto object detected. This is required for the following operation: "
|
||
},
|
||
invalidCacheType: {
|
||
code: "invalid_cache_type",
|
||
desc: "Invalid cache type"
|
||
},
|
||
unexpectedAccountType: {
|
||
code: "unexpected_account_type",
|
||
desc: "Unexpected account type."
|
||
},
|
||
unexpectedCredentialType: {
|
||
code: "unexpected_credential_type",
|
||
desc: "Unexpected credential type."
|
||
},
|
||
invalidAssertion: {
|
||
code: "invalid_assertion",
|
||
desc: "Client assertion must meet requirements described in https://tools.ietf.org/html/rfc7515"
|
||
},
|
||
invalidClientCredential: {
|
||
code: "invalid_client_credential",
|
||
desc: "Client credential (secret, certificate, or assertion) must not be empty when creating a confidential client. An application should at most have one credential"
|
||
},
|
||
tokenRefreshRequired: {
|
||
code: "token_refresh_required",
|
||
desc: "Cannot return token from cache because it must be refreshed. This may be due to one of the following reasons: forceRefresh parameter is set to true, claims have been requested, there is no cached access token or it is expired."
|
||
},
|
||
userTimeoutReached: {
|
||
code: "user_timeout_reached",
|
||
desc: "User defined timeout for device code polling reached",
|
||
},
|
||
tokenClaimsRequired: {
|
||
code: "token_claims_cnf_required_for_signedjwt",
|
||
desc: "Cannot generate a POP jwt if the token_claims are not populated"
|
||
},
|
||
noAuthorizationCodeFromServer: {
|
||
code: "authorization_code_missing_from_server_response",
|
||
desc: "Srver response does not contain an authorization code to proceed"
|
||
}
|
||
};
|
||
/**
|
||
* Error thrown when there is an error in the client code running on the browser.
|
||
*/
|
||
var ClientAuthError = /** @class */ (function (_super) {
|
||
__extends(ClientAuthError, _super);
|
||
function ClientAuthError(errorCode, errorMessage) {
|
||
var _this = _super.call(this, errorCode, errorMessage) || this;
|
||
_this.name = "ClientAuthError";
|
||
Object.setPrototypeOf(_this, ClientAuthError.prototype);
|
||
return _this;
|
||
}
|
||
/**
|
||
* Creates an error thrown when client info object doesn't decode correctly.
|
||
* @param caughtError
|
||
*/
|
||
ClientAuthError.createClientInfoDecodingError = function (caughtError) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.clientInfoDecodingError.code, ClientAuthErrorMessage.clientInfoDecodingError.desc + " Failed with error: " + caughtError);
|
||
};
|
||
/**
|
||
* Creates an error thrown if the client info is empty.
|
||
* @param rawClientInfo
|
||
*/
|
||
ClientAuthError.createClientInfoEmptyError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.clientInfoEmptyError.code, "" + ClientAuthErrorMessage.clientInfoEmptyError.desc);
|
||
};
|
||
/**
|
||
* Creates an error thrown when the id token extraction errors out.
|
||
* @param err
|
||
*/
|
||
ClientAuthError.createTokenParsingError = function (caughtExtractionError) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.tokenParsingError.code, ClientAuthErrorMessage.tokenParsingError.desc + " Failed with error: " + caughtExtractionError);
|
||
};
|
||
/**
|
||
* Creates an error thrown when the id token string is null or empty.
|
||
* @param invalidRawTokenString
|
||
*/
|
||
ClientAuthError.createTokenNullOrEmptyError = function (invalidRawTokenString) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.nullOrEmptyToken.code, ClientAuthErrorMessage.nullOrEmptyToken.desc + " Raw Token Value: " + invalidRawTokenString);
|
||
};
|
||
/**
|
||
* Creates an error thrown when the endpoint discovery doesn't complete correctly.
|
||
*/
|
||
ClientAuthError.createEndpointDiscoveryIncompleteError = function (errDetail) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.endpointResolutionError.code, ClientAuthErrorMessage.endpointResolutionError.desc + " Detail: " + errDetail);
|
||
};
|
||
/**
|
||
* Creates an error thrown when the openid-configuration endpoint cannot be reached or does not contain the required data
|
||
*/
|
||
ClientAuthError.createUnableToGetOpenidConfigError = function (errDetail) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.unableToGetOpenidConfigError.code, ClientAuthErrorMessage.unableToGetOpenidConfigError.desc + " Attempted to retrieve endpoints from: " + errDetail);
|
||
};
|
||
/**
|
||
* Creates an error thrown when the hash cannot be deserialized.
|
||
* @param hashParamObj
|
||
*/
|
||
ClientAuthError.createHashNotDeserializedError = function (hashParamObj) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.hashNotDeserialized.code, ClientAuthErrorMessage.hashNotDeserialized.desc + " Given Object: " + hashParamObj);
|
||
};
|
||
/**
|
||
* Creates an error thrown when the state cannot be parsed.
|
||
* @param invalidState
|
||
*/
|
||
ClientAuthError.createInvalidStateError = function (invalidState, errorString) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.invalidStateError.code, ClientAuthErrorMessage.invalidStateError.desc + " Invalid State: " + invalidState + ", Root Err: " + errorString);
|
||
};
|
||
/**
|
||
* Creates an error thrown when two states do not match.
|
||
*/
|
||
ClientAuthError.createStateMismatchError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.stateMismatchError.code, ClientAuthErrorMessage.stateMismatchError.desc);
|
||
};
|
||
/**
|
||
* Creates an error thrown when the state is not present
|
||
* @param missingState
|
||
*/
|
||
ClientAuthError.createStateNotFoundError = function (missingState) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.stateNotFoundError.code, ClientAuthErrorMessage.stateNotFoundError.desc + ": " + missingState);
|
||
};
|
||
/**
|
||
* Creates an error thrown when the nonce does not match.
|
||
*/
|
||
ClientAuthError.createNonceMismatchError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.nonceMismatchError.code, ClientAuthErrorMessage.nonceMismatchError.desc);
|
||
};
|
||
/**
|
||
* Creates an error thrown when the mnonce is not present
|
||
* @param missingNonce
|
||
*/
|
||
ClientAuthError.createNonceNotFoundError = function (missingNonce) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.nonceNotFoundError.code, ClientAuthErrorMessage.nonceNotFoundError.desc + ": " + missingNonce);
|
||
};
|
||
/**
|
||
* Creates an error thrown when the authorization code required for a token request is null or empty.
|
||
*/
|
||
ClientAuthError.createNoTokensFoundError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.noTokensFoundError.code, ClientAuthErrorMessage.noTokensFoundError.desc);
|
||
};
|
||
/**
|
||
* Throws error when multiple tokens are in cache.
|
||
*/
|
||
ClientAuthError.createMultipleMatchingTokensInCacheError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.multipleMatchingTokens.code, ClientAuthErrorMessage.multipleMatchingTokens.desc + ".");
|
||
};
|
||
/**
|
||
* Throws error when multiple accounts are in cache for the given params
|
||
*/
|
||
ClientAuthError.createMultipleMatchingAccountsInCacheError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.multipleMatchingAccounts.code, ClientAuthErrorMessage.multipleMatchingAccounts.desc);
|
||
};
|
||
/**
|
||
* Throws error when multiple appMetada are in cache for the given clientId.
|
||
*/
|
||
ClientAuthError.createMultipleMatchingAppMetadataInCacheError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.multipleMatchingAppMetadata.code, ClientAuthErrorMessage.multipleMatchingAppMetadata.desc);
|
||
};
|
||
/**
|
||
* Throws error when no auth code or refresh token is given to ServerTokenRequestParameters.
|
||
*/
|
||
ClientAuthError.createTokenRequestCannotBeMadeError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.tokenRequestCannotBeMade.code, ClientAuthErrorMessage.tokenRequestCannotBeMade.desc);
|
||
};
|
||
/**
|
||
* Throws error when attempting to append a null, undefined or empty scope to a set
|
||
* @param givenScope
|
||
*/
|
||
ClientAuthError.createAppendEmptyScopeToSetError = function (givenScope) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.appendEmptyScopeError.code, ClientAuthErrorMessage.appendEmptyScopeError.desc + " Given Scope: " + givenScope);
|
||
};
|
||
/**
|
||
* Throws error when attempting to append a null, undefined or empty scope to a set
|
||
* @param givenScope
|
||
*/
|
||
ClientAuthError.createRemoveEmptyScopeFromSetError = function (givenScope) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.removeEmptyScopeError.code, ClientAuthErrorMessage.removeEmptyScopeError.desc + " Given Scope: " + givenScope);
|
||
};
|
||
/**
|
||
* Throws error when attempting to append null or empty ScopeSet.
|
||
* @param appendError
|
||
*/
|
||
ClientAuthError.createAppendScopeSetError = function (appendError) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.appendScopeSetError.code, ClientAuthErrorMessage.appendScopeSetError.desc + " Detail Error: " + appendError);
|
||
};
|
||
/**
|
||
* Throws error if ScopeSet is null or undefined.
|
||
* @param givenScopeSet
|
||
*/
|
||
ClientAuthError.createEmptyInputScopeSetError = function (givenScopeSet) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.emptyInputScopeSetError.code, ClientAuthErrorMessage.emptyInputScopeSetError.desc + " Given ScopeSet: " + givenScopeSet);
|
||
};
|
||
/**
|
||
* Throws error if user sets CancellationToken.cancel = true during polling of token endpoint during device code flow
|
||
*/
|
||
ClientAuthError.createDeviceCodeCancelledError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.DeviceCodePollingCancelled.code, "" + ClientAuthErrorMessage.DeviceCodePollingCancelled.desc);
|
||
};
|
||
/**
|
||
* Throws error if device code is expired
|
||
*/
|
||
ClientAuthError.createDeviceCodeExpiredError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.DeviceCodeExpired.code, "" + ClientAuthErrorMessage.DeviceCodeExpired.desc);
|
||
};
|
||
/**
|
||
* Throws error when silent requests are made without an account object
|
||
*/
|
||
ClientAuthError.createNoAccountInSilentRequestError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.NoAccountInSilentRequest.code, "" + ClientAuthErrorMessage.NoAccountInSilentRequest.desc);
|
||
};
|
||
/**
|
||
* Throws error when cache record is null or undefined.
|
||
*/
|
||
ClientAuthError.createNullOrUndefinedCacheRecord = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.invalidCacheRecord.code, ClientAuthErrorMessage.invalidCacheRecord.desc);
|
||
};
|
||
/**
|
||
* Throws error when provided environment is not part of the CloudDiscoveryMetadata object
|
||
*/
|
||
ClientAuthError.createInvalidCacheEnvironmentError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.invalidCacheEnvironment.code, ClientAuthErrorMessage.invalidCacheEnvironment.desc);
|
||
};
|
||
/**
|
||
* Throws error when account is not found in cache.
|
||
*/
|
||
ClientAuthError.createNoAccountFoundError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.noAccountFound.code, ClientAuthErrorMessage.noAccountFound.desc);
|
||
};
|
||
/**
|
||
* Throws error if ICachePlugin not set on CacheManager.
|
||
*/
|
||
ClientAuthError.createCachePluginError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.CachePluginError.code, "" + ClientAuthErrorMessage.CachePluginError.desc);
|
||
};
|
||
/**
|
||
* Throws error if crypto object not found.
|
||
* @param operationName
|
||
*/
|
||
ClientAuthError.createNoCryptoObjectError = function (operationName) {
|
||
return new ClientAuthError(ClientAuthErrorMessage.noCryptoObj.code, "" + ClientAuthErrorMessage.noCryptoObj.desc + operationName);
|
||
};
|
||
/**
|
||
* Throws error if cache type is invalid.
|
||
*/
|
||
ClientAuthError.createInvalidCacheTypeError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.invalidCacheType.code, "" + ClientAuthErrorMessage.invalidCacheType.desc);
|
||
};
|
||
/**
|
||
* Throws error if unexpected account type.
|
||
*/
|
||
ClientAuthError.createUnexpectedAccountTypeError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.unexpectedAccountType.code, "" + ClientAuthErrorMessage.unexpectedAccountType.desc);
|
||
};
|
||
/**
|
||
* Throws error if unexpected credential type.
|
||
*/
|
||
ClientAuthError.createUnexpectedCredentialTypeError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.unexpectedCredentialType.code, "" + ClientAuthErrorMessage.unexpectedCredentialType.desc);
|
||
};
|
||
/**
|
||
* Throws error if client assertion is not valid.
|
||
*/
|
||
ClientAuthError.createInvalidAssertionError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.invalidAssertion.code, "" + ClientAuthErrorMessage.invalidAssertion.desc);
|
||
};
|
||
/**
|
||
* Throws error if client assertion is not valid.
|
||
*/
|
||
ClientAuthError.createInvalidCredentialError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.invalidClientCredential.code, "" + ClientAuthErrorMessage.invalidClientCredential.desc);
|
||
};
|
||
/**
|
||
* Throws error if token cannot be retrieved from cache due to refresh being required.
|
||
*/
|
||
ClientAuthError.createRefreshRequiredError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.tokenRefreshRequired.code, ClientAuthErrorMessage.tokenRefreshRequired.desc);
|
||
};
|
||
/**
|
||
* Throws error if the user defined timeout is reached.
|
||
*/
|
||
ClientAuthError.createUserTimeoutReachedError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.userTimeoutReached.code, ClientAuthErrorMessage.userTimeoutReached.desc);
|
||
};
|
||
/*
|
||
* Throws error if token claims are not populated for a signed jwt generation
|
||
*/
|
||
ClientAuthError.createTokenClaimsRequiredError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.tokenClaimsRequired.code, ClientAuthErrorMessage.tokenClaimsRequired.desc);
|
||
};
|
||
/**
|
||
* Throws error when the authorization code is missing from the server response
|
||
*/
|
||
ClientAuthError.createNoAuthCodeInServerResponseError = function () {
|
||
return new ClientAuthError(ClientAuthErrorMessage.noAuthorizationCodeFromServer.code, ClientAuthErrorMessage.noAuthorizationCodeFromServer.desc);
|
||
};
|
||
return ClientAuthError;
|
||
}(AuthError));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* @hidden
|
||
*/
|
||
var StringUtils = /** @class */ (function () {
|
||
function StringUtils() {
|
||
}
|
||
/**
|
||
* decode a JWT
|
||
*
|
||
* @param authToken
|
||
*/
|
||
StringUtils.decodeAuthToken = function (authToken) {
|
||
if (StringUtils.isEmpty(authToken)) {
|
||
throw ClientAuthError.createTokenNullOrEmptyError(authToken);
|
||
}
|
||
var tokenPartsRegex = /^([^\.\s]*)\.([^\.\s]+)\.([^\.\s]*)$/;
|
||
var matches = tokenPartsRegex.exec(authToken);
|
||
if (!matches || matches.length < 4) {
|
||
throw ClientAuthError.createTokenParsingError("Given token is malformed: " + JSON.stringify(authToken));
|
||
}
|
||
var crackedToken = {
|
||
header: matches[1],
|
||
JWSPayload: matches[2],
|
||
JWSSig: matches[3]
|
||
};
|
||
return crackedToken;
|
||
};
|
||
/**
|
||
* Check if a string is empty.
|
||
*
|
||
* @param str
|
||
*/
|
||
StringUtils.isEmpty = function (str) {
|
||
return (typeof str === "undefined" || !str || 0 === str.length);
|
||
};
|
||
StringUtils.startsWith = function (str, search) {
|
||
return str.indexOf(search) === 0;
|
||
};
|
||
StringUtils.endsWith = function (str, search) {
|
||
return (str.length >= search.length) && (str.lastIndexOf(search) === (str.length - search.length));
|
||
};
|
||
/**
|
||
* Parses string into an object.
|
||
*
|
||
* @param query
|
||
*/
|
||
StringUtils.queryStringToObject = function (query) {
|
||
var match; // Regex for replacing addition symbol with a space
|
||
var pl = /\+/g;
|
||
var search = /([^&=]+)=([^&]*)/g;
|
||
var decode = function (s) { return decodeURIComponent(decodeURIComponent(s.replace(pl, " "))); };
|
||
var obj = {};
|
||
match = search.exec(query);
|
||
while (match) {
|
||
obj[decode(match[1])] = decode(match[2]);
|
||
match = search.exec(query);
|
||
}
|
||
return obj;
|
||
};
|
||
/**
|
||
* Trims entries in an array.
|
||
*
|
||
* @param arr
|
||
*/
|
||
StringUtils.trimArrayEntries = function (arr) {
|
||
return arr.map(function (entry) { return entry.trim(); });
|
||
};
|
||
/**
|
||
* Removes empty strings from array
|
||
* @param arr
|
||
*/
|
||
StringUtils.removeEmptyStringsFromArray = function (arr) {
|
||
return arr.filter(function (entry) {
|
||
return !StringUtils.isEmpty(entry);
|
||
});
|
||
};
|
||
/**
|
||
* Attempts to parse a string into JSON
|
||
* @param str
|
||
*/
|
||
StringUtils.jsonParseHelper = function (str) {
|
||
try {
|
||
return JSON.parse(str);
|
||
}
|
||
catch (e) {
|
||
return null;
|
||
}
|
||
};
|
||
/**
|
||
* Tests if a given string matches a given pattern, with support for wildcards.
|
||
* @param pattern Wildcard pattern to string match. Supports "*" for wildcards
|
||
* @param input String to match against
|
||
*/
|
||
StringUtils.matchPattern = function (pattern, input) {
|
||
// https://stackoverflow.com/a/3117248/4888559
|
||
var regex = new RegExp(pattern.replace(/\*/g, "[^ ]*"));
|
||
return regex.test(input);
|
||
};
|
||
return StringUtils;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Log message level.
|
||
*/
|
||
var LogLevel;
|
||
(function (LogLevel) {
|
||
LogLevel[LogLevel["Error"] = 0] = "Error";
|
||
LogLevel[LogLevel["Warning"] = 1] = "Warning";
|
||
LogLevel[LogLevel["Info"] = 2] = "Info";
|
||
LogLevel[LogLevel["Verbose"] = 3] = "Verbose";
|
||
})(LogLevel || (LogLevel = {}));
|
||
/**
|
||
* Class which facilitates logging of messages to a specific place.
|
||
*/
|
||
var Logger = /** @class */ (function () {
|
||
function Logger(loggerOptions, packageName, packageVersion) {
|
||
// Current log level, defaults to info.
|
||
this.level = LogLevel.Info;
|
||
var defaultLoggerCallback = function () { };
|
||
this.localCallback = loggerOptions.loggerCallback || defaultLoggerCallback;
|
||
this.piiLoggingEnabled = loggerOptions.piiLoggingEnabled || false;
|
||
this.level = loggerOptions.logLevel || LogLevel.Info;
|
||
this.packageName = packageName || Constants.EMPTY_STRING;
|
||
this.packageVersion = packageVersion || Constants.EMPTY_STRING;
|
||
}
|
||
/**
|
||
* Create new Logger with existing configurations.
|
||
*/
|
||
Logger.prototype.clone = function (packageName, packageVersion) {
|
||
return new Logger({ loggerCallback: this.localCallback, piiLoggingEnabled: this.piiLoggingEnabled, logLevel: this.level }, packageName, packageVersion);
|
||
};
|
||
/**
|
||
* Log message with required options.
|
||
*/
|
||
Logger.prototype.logMessage = function (logMessage, options) {
|
||
if ((options.logLevel > this.level) || (!this.piiLoggingEnabled && options.containsPii)) {
|
||
return;
|
||
}
|
||
var timestamp = new Date().toUTCString();
|
||
var logHeader = StringUtils.isEmpty(this.correlationId) ? "[" + timestamp + "] : " : "[" + timestamp + "] : [" + this.correlationId + "]";
|
||
var log = logHeader + " : " + this.packageName + "@" + this.packageVersion + " : " + LogLevel[options.logLevel] + " - " + logMessage;
|
||
// debug(`msal:${LogLevel[options.logLevel]}${options.containsPii ? "-Pii": ""}${options.context ? `:${options.context}` : ""}`)(logMessage);
|
||
this.executeCallback(options.logLevel, log, options.containsPii || false);
|
||
};
|
||
/**
|
||
* Execute callback with message.
|
||
*/
|
||
Logger.prototype.executeCallback = function (level, message, containsPii) {
|
||
if (this.localCallback) {
|
||
this.localCallback(level, message, containsPii);
|
||
}
|
||
};
|
||
/**
|
||
* Logs error messages.
|
||
*/
|
||
Logger.prototype.error = function (message, correlationId) {
|
||
this.logMessage(message, {
|
||
logLevel: LogLevel.Error,
|
||
containsPii: false,
|
||
correlationId: correlationId || ""
|
||
});
|
||
};
|
||
/**
|
||
* Logs error messages with PII.
|
||
*/
|
||
Logger.prototype.errorPii = function (message, correlationId) {
|
||
this.logMessage(message, {
|
||
logLevel: LogLevel.Error,
|
||
containsPii: true,
|
||
correlationId: correlationId || ""
|
||
});
|
||
};
|
||
/**
|
||
* Logs warning messages.
|
||
*/
|
||
Logger.prototype.warning = function (message, correlationId) {
|
||
this.logMessage(message, {
|
||
logLevel: LogLevel.Warning,
|
||
containsPii: false,
|
||
correlationId: correlationId || ""
|
||
});
|
||
};
|
||
/**
|
||
* Logs warning messages with PII.
|
||
*/
|
||
Logger.prototype.warningPii = function (message, correlationId) {
|
||
this.logMessage(message, {
|
||
logLevel: LogLevel.Warning,
|
||
containsPii: true,
|
||
correlationId: correlationId || ""
|
||
});
|
||
};
|
||
/**
|
||
* Logs info messages.
|
||
*/
|
||
Logger.prototype.info = function (message, correlationId) {
|
||
this.logMessage(message, {
|
||
logLevel: LogLevel.Info,
|
||
containsPii: false,
|
||
correlationId: correlationId || ""
|
||
});
|
||
};
|
||
/**
|
||
* Logs info messages with PII.
|
||
*/
|
||
Logger.prototype.infoPii = function (message, correlationId) {
|
||
this.logMessage(message, {
|
||
logLevel: LogLevel.Info,
|
||
containsPii: true,
|
||
correlationId: correlationId || ""
|
||
});
|
||
};
|
||
/**
|
||
* Logs verbose messages.
|
||
*/
|
||
Logger.prototype.verbose = function (message, correlationId) {
|
||
this.logMessage(message, {
|
||
logLevel: LogLevel.Verbose,
|
||
containsPii: false,
|
||
correlationId: correlationId || ""
|
||
});
|
||
};
|
||
/**
|
||
* Logs verbose messages with PII.
|
||
*/
|
||
Logger.prototype.verbosePii = function (message, correlationId) {
|
||
this.logMessage(message, {
|
||
logLevel: LogLevel.Verbose,
|
||
containsPii: true,
|
||
correlationId: correlationId || ""
|
||
});
|
||
};
|
||
/**
|
||
* Returns whether PII Logging is enabled or not.
|
||
*/
|
||
Logger.prototype.isPiiLoggingEnabled = function () {
|
||
return this.piiLoggingEnabled || false;
|
||
};
|
||
return Logger;
|
||
}());
|
||
|
||
/* eslint-disable header/header */
|
||
var name = "@azure/msal-common";
|
||
var version = "4.0.1";
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Base type for credentials to be stored in the cache: eg: ACCESS_TOKEN, ID_TOKEN etc
|
||
*
|
||
* Key:Value Schema:
|
||
*
|
||
* Key: <home_account_id*>-<environment>-<credential_type>-<client_id>-<realm*>-<target*>
|
||
*
|
||
* Value Schema:
|
||
* {
|
||
* homeAccountId: home account identifier for the auth scheme,
|
||
* environment: entity that issued the token, represented as a full host
|
||
* credentialType: Type of credential as a string, can be one of the following: RefreshToken, AccessToken, IdToken, Password, Cookie, Certificate, Other
|
||
* clientId: client ID of the application
|
||
* secret: Actual credential as a string
|
||
* familyId: Family ID identifier, usually only used for refresh tokens
|
||
* realm: Full tenant or organizational identifier that the account belongs to
|
||
* target: Permissions that are included in the token, or for refresh tokens, the resource identifier.
|
||
* oboAssertion: access token passed in as part of OBO request
|
||
* }
|
||
*/
|
||
var CredentialEntity = /** @class */ (function () {
|
||
function CredentialEntity() {
|
||
}
|
||
/**
|
||
* Generate Account Id key component as per the schema: <home_account_id>-<environment>
|
||
*/
|
||
CredentialEntity.prototype.generateAccountId = function () {
|
||
return CredentialEntity.generateAccountIdForCacheKey(this.homeAccountId, this.environment);
|
||
};
|
||
/**
|
||
* Generate Credential Id key component as per the schema: <credential_type>-<client_id>-<realm>
|
||
*/
|
||
CredentialEntity.prototype.generateCredentialId = function () {
|
||
return CredentialEntity.generateCredentialIdForCacheKey(this.credentialType, this.clientId, this.realm, this.familyId);
|
||
};
|
||
/**
|
||
* Generate target key component as per schema: <target>
|
||
*/
|
||
CredentialEntity.prototype.generateTarget = function () {
|
||
return CredentialEntity.generateTargetForCacheKey(this.target);
|
||
};
|
||
/**
|
||
* generates credential key
|
||
*/
|
||
CredentialEntity.prototype.generateCredentialKey = function () {
|
||
return CredentialEntity.generateCredentialCacheKey(this.homeAccountId, this.environment, this.credentialType, this.clientId, this.realm, this.target, this.familyId);
|
||
};
|
||
/**
|
||
* returns the type of the cache (in this case credential)
|
||
*/
|
||
CredentialEntity.prototype.generateType = function () {
|
||
switch (this.credentialType) {
|
||
case CredentialType.ID_TOKEN:
|
||
return CacheType.ID_TOKEN;
|
||
case CredentialType.ACCESS_TOKEN:
|
||
return CacheType.ACCESS_TOKEN;
|
||
case CredentialType.REFRESH_TOKEN:
|
||
return CacheType.REFRESH_TOKEN;
|
||
default: {
|
||
throw ClientAuthError.createUnexpectedCredentialTypeError();
|
||
}
|
||
}
|
||
};
|
||
/**
|
||
* helper function to return `CredentialType`
|
||
* @param key
|
||
*/
|
||
CredentialEntity.getCredentialType = function (key) {
|
||
if (key.indexOf(CredentialType.ACCESS_TOKEN.toLowerCase()) !== -1) {
|
||
return CredentialType.ACCESS_TOKEN;
|
||
}
|
||
else if (key.indexOf(CredentialType.ID_TOKEN.toLowerCase()) !== -1) {
|
||
return CredentialType.ID_TOKEN;
|
||
}
|
||
else if (key.indexOf(CredentialType.REFRESH_TOKEN.toLowerCase()) !== -1) {
|
||
return CredentialType.REFRESH_TOKEN;
|
||
}
|
||
return Constants.NOT_DEFINED;
|
||
};
|
||
/**
|
||
* generates credential key
|
||
*/
|
||
CredentialEntity.generateCredentialCacheKey = function (homeAccountId, environment, credentialType, clientId, realm, target, familyId) {
|
||
var credentialKey = [
|
||
this.generateAccountIdForCacheKey(homeAccountId, environment),
|
||
this.generateCredentialIdForCacheKey(credentialType, clientId, realm, familyId),
|
||
this.generateTargetForCacheKey(target),
|
||
];
|
||
return credentialKey.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
|
||
};
|
||
/**
|
||
* generates Account Id for keys
|
||
* @param homeAccountId
|
||
* @param environment
|
||
*/
|
||
CredentialEntity.generateAccountIdForCacheKey = function (homeAccountId, environment) {
|
||
var accountId = [homeAccountId, environment];
|
||
return accountId.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
|
||
};
|
||
/**
|
||
* Generates Credential Id for keys
|
||
* @param credentialType
|
||
* @param realm
|
||
* @param clientId
|
||
* @param familyId
|
||
*/
|
||
CredentialEntity.generateCredentialIdForCacheKey = function (credentialType, clientId, realm, familyId) {
|
||
var clientOrFamilyId = credentialType === CredentialType.REFRESH_TOKEN
|
||
? familyId || clientId
|
||
: clientId;
|
||
var credentialId = [
|
||
credentialType,
|
||
clientOrFamilyId,
|
||
realm || "",
|
||
];
|
||
return credentialId.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
|
||
};
|
||
/**
|
||
* Generate target key component as per schema: <target>
|
||
*/
|
||
CredentialEntity.generateTargetForCacheKey = function (scopes) {
|
||
return (scopes || "").toLowerCase();
|
||
};
|
||
return CredentialEntity;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* ClientConfigurationErrorMessage class containing string constants used by error codes and messages.
|
||
*/
|
||
var ClientConfigurationErrorMessage = {
|
||
redirectUriNotSet: {
|
||
code: "redirect_uri_empty",
|
||
desc: "A redirect URI is required for all calls, and none has been set."
|
||
},
|
||
postLogoutUriNotSet: {
|
||
code: "post_logout_uri_empty",
|
||
desc: "A post logout redirect has not been set."
|
||
},
|
||
claimsRequestParsingError: {
|
||
code: "claims_request_parsing_error",
|
||
desc: "Could not parse the given claims request object."
|
||
},
|
||
authorityUriInsecure: {
|
||
code: "authority_uri_insecure",
|
||
desc: "Authority URIs must use https. Please see here for valid authority configuration options: https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-js-initializing-client-applications#configuration-options"
|
||
},
|
||
urlParseError: {
|
||
code: "url_parse_error",
|
||
desc: "URL could not be parsed into appropriate segments."
|
||
},
|
||
urlEmptyError: {
|
||
code: "empty_url_error",
|
||
desc: "URL was empty or null."
|
||
},
|
||
emptyScopesError: {
|
||
code: "empty_input_scopes_error",
|
||
desc: "Scopes cannot be passed as null, undefined or empty array because they are required to obtain an access token."
|
||
},
|
||
nonArrayScopesError: {
|
||
code: "nonarray_input_scopes_error",
|
||
desc: "Scopes cannot be passed as non-array."
|
||
},
|
||
clientIdSingleScopeError: {
|
||
code: "clientid_input_scopes_error",
|
||
desc: "Client ID can only be provided as a single scope."
|
||
},
|
||
invalidPrompt: {
|
||
code: "invalid_prompt_value",
|
||
desc: "Supported prompt values are 'login', 'select_account', 'consent' and 'none'. Please see here for valid configuration options: https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-js-initializing-client-applications#configuration-options",
|
||
},
|
||
invalidClaimsRequest: {
|
||
code: "invalid_claims",
|
||
desc: "Given claims parameter must be a stringified JSON object."
|
||
},
|
||
tokenRequestEmptyError: {
|
||
code: "token_request_empty",
|
||
desc: "Token request was empty and not found in cache."
|
||
},
|
||
logoutRequestEmptyError: {
|
||
code: "logout_request_empty",
|
||
desc: "The logout request was null or undefined."
|
||
},
|
||
invalidCodeChallengeMethod: {
|
||
code: "invalid_code_challenge_method",
|
||
desc: "code_challenge_method passed is invalid. Valid values are \"plain\" and \"S256\"."
|
||
},
|
||
invalidCodeChallengeParams: {
|
||
code: "pkce_params_missing",
|
||
desc: "Both params: code_challenge and code_challenge_method are to be passed if to be sent in the request"
|
||
},
|
||
invalidCloudDiscoveryMetadata: {
|
||
code: "invalid_cloud_discovery_metadata",
|
||
desc: "Invalid cloudDiscoveryMetadata provided. Must be a JSON object containing tenant_discovery_endpoint and metadata fields"
|
||
},
|
||
invalidAuthorityMetadata: {
|
||
code: "invalid_authority_metadata",
|
||
desc: "Invalid authorityMetadata provided. Must by a JSON object containing authorization_endpoint, token_endpoint, end_session_endpoint, issuer fields."
|
||
},
|
||
untrustedAuthority: {
|
||
code: "untrusted_authority",
|
||
desc: "The provided authority is not a trusted authority. Please include this authority in the knownAuthorities config parameter."
|
||
},
|
||
resourceRequestParametersRequired: {
|
||
code: "resourceRequest_parameters_required",
|
||
desc: "resourceRequestMethod and resourceRequestUri are required"
|
||
}
|
||
};
|
||
/**
|
||
* Error thrown when there is an error in configuration of the MSAL.js library.
|
||
*/
|
||
var ClientConfigurationError = /** @class */ (function (_super) {
|
||
__extends(ClientConfigurationError, _super);
|
||
function ClientConfigurationError(errorCode, errorMessage) {
|
||
var _this = _super.call(this, errorCode, errorMessage) || this;
|
||
_this.name = "ClientConfigurationError";
|
||
Object.setPrototypeOf(_this, ClientConfigurationError.prototype);
|
||
return _this;
|
||
}
|
||
/**
|
||
* Creates an error thrown when the redirect uri is empty (not set by caller)
|
||
*/
|
||
ClientConfigurationError.createRedirectUriEmptyError = function () {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.redirectUriNotSet.code, ClientConfigurationErrorMessage.redirectUriNotSet.desc);
|
||
};
|
||
/**
|
||
* Creates an error thrown when the post-logout redirect uri is empty (not set by caller)
|
||
*/
|
||
ClientConfigurationError.createPostLogoutRedirectUriEmptyError = function () {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.postLogoutUriNotSet.code, ClientConfigurationErrorMessage.postLogoutUriNotSet.desc);
|
||
};
|
||
/**
|
||
* Creates an error thrown when the claims request could not be successfully parsed
|
||
*/
|
||
ClientConfigurationError.createClaimsRequestParsingError = function (claimsRequestParseError) {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.claimsRequestParsingError.code, ClientConfigurationErrorMessage.claimsRequestParsingError.desc + " Given value: " + claimsRequestParseError);
|
||
};
|
||
/**
|
||
* Creates an error thrown if authority uri is given an insecure protocol.
|
||
* @param urlString
|
||
*/
|
||
ClientConfigurationError.createInsecureAuthorityUriError = function (urlString) {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.authorityUriInsecure.code, ClientConfigurationErrorMessage.authorityUriInsecure.desc + " Given URI: " + urlString);
|
||
};
|
||
/**
|
||
* Creates an error thrown if URL string does not parse into separate segments.
|
||
* @param urlString
|
||
*/
|
||
ClientConfigurationError.createUrlParseError = function (urlParseError) {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.urlParseError.code, ClientConfigurationErrorMessage.urlParseError.desc + " Given Error: " + urlParseError);
|
||
};
|
||
/**
|
||
* Creates an error thrown if URL string is empty or null.
|
||
* @param urlString
|
||
*/
|
||
ClientConfigurationError.createUrlEmptyError = function () {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.urlEmptyError.code, ClientConfigurationErrorMessage.urlEmptyError.desc);
|
||
};
|
||
/**
|
||
* Error thrown when scopes are not an array
|
||
* @param inputScopes
|
||
*/
|
||
ClientConfigurationError.createScopesNonArrayError = function (inputScopes) {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.nonArrayScopesError.code, ClientConfigurationErrorMessage.nonArrayScopesError.desc + " Given Scopes: " + inputScopes);
|
||
};
|
||
/**
|
||
* Error thrown when scopes are empty.
|
||
* @param scopesValue
|
||
*/
|
||
ClientConfigurationError.createEmptyScopesArrayError = function (inputScopes) {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.emptyScopesError.code, ClientConfigurationErrorMessage.emptyScopesError.desc + " Given Scopes: " + inputScopes);
|
||
};
|
||
/**
|
||
* Error thrown when client id scope is not provided as single scope.
|
||
* @param inputScopes
|
||
*/
|
||
ClientConfigurationError.createClientIdSingleScopeError = function (inputScopes) {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.clientIdSingleScopeError.code, ClientConfigurationErrorMessage.clientIdSingleScopeError.desc + " Given Scopes: " + inputScopes);
|
||
};
|
||
/**
|
||
* Error thrown when prompt is not an allowed type.
|
||
* @param promptValue
|
||
*/
|
||
ClientConfigurationError.createInvalidPromptError = function (promptValue) {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.invalidPrompt.code, ClientConfigurationErrorMessage.invalidPrompt.desc + " Given value: " + promptValue);
|
||
};
|
||
/**
|
||
* Creates error thrown when claims parameter is not a stringified JSON object
|
||
*/
|
||
ClientConfigurationError.createInvalidClaimsRequestError = function () {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.invalidClaimsRequest.code, ClientConfigurationErrorMessage.invalidClaimsRequest.desc);
|
||
};
|
||
/**
|
||
* Throws error when token request is empty and nothing cached in storage.
|
||
*/
|
||
ClientConfigurationError.createEmptyLogoutRequestError = function () {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.logoutRequestEmptyError.code, ClientConfigurationErrorMessage.logoutRequestEmptyError.desc);
|
||
};
|
||
/**
|
||
* Throws error when token request is empty and nothing cached in storage.
|
||
*/
|
||
ClientConfigurationError.createEmptyTokenRequestError = function () {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.tokenRequestEmptyError.code, ClientConfigurationErrorMessage.tokenRequestEmptyError.desc);
|
||
};
|
||
/**
|
||
* Throws error when an invalid code_challenge_method is passed by the user
|
||
*/
|
||
ClientConfigurationError.createInvalidCodeChallengeMethodError = function () {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.invalidCodeChallengeMethod.code, ClientConfigurationErrorMessage.invalidCodeChallengeMethod.desc);
|
||
};
|
||
/**
|
||
* Throws error when both params: code_challenge and code_challenge_method are not passed together
|
||
*/
|
||
ClientConfigurationError.createInvalidCodeChallengeParamsError = function () {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.invalidCodeChallengeParams.code, ClientConfigurationErrorMessage.invalidCodeChallengeParams.desc);
|
||
};
|
||
/**
|
||
* Throws an error when the user passes invalid cloudDiscoveryMetadata
|
||
*/
|
||
ClientConfigurationError.createInvalidCloudDiscoveryMetadataError = function () {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.invalidCloudDiscoveryMetadata.code, ClientConfigurationErrorMessage.invalidCloudDiscoveryMetadata.desc);
|
||
};
|
||
/**
|
||
* Throws an error when the user passes invalid cloudDiscoveryMetadata
|
||
*/
|
||
ClientConfigurationError.createInvalidAuthorityMetadataError = function () {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.invalidAuthorityMetadata.code, ClientConfigurationErrorMessage.invalidAuthorityMetadata.desc);
|
||
};
|
||
/**
|
||
* Throws error when provided authority is not a member of the trusted host list
|
||
*/
|
||
ClientConfigurationError.createUntrustedAuthorityError = function () {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.untrustedAuthority.code, ClientConfigurationErrorMessage.untrustedAuthority.desc);
|
||
};
|
||
/**
|
||
* Throws error when resourceRequestMethod or resourceRequestUri is missing
|
||
*/
|
||
ClientConfigurationError.createResourceRequestParametersRequiredError = function () {
|
||
return new ClientConfigurationError(ClientConfigurationErrorMessage.resourceRequestParametersRequired.code, ClientConfigurationErrorMessage.resourceRequestParametersRequired.desc);
|
||
};
|
||
return ClientConfigurationError;
|
||
}(ClientAuthError));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* The ScopeSet class creates a set of scopes. Scopes are case-insensitive, unique values, so the Set object in JS makes
|
||
* the most sense to implement for this class. All scopes are trimmed and converted to lower case strings in intersection and union functions
|
||
* to ensure uniqueness of strings.
|
||
*/
|
||
var ScopeSet = /** @class */ (function () {
|
||
function ScopeSet(inputScopes) {
|
||
var _this = this;
|
||
// Filter empty string and null/undefined array items
|
||
var scopeArr = inputScopes ? StringUtils.trimArrayEntries(__spreadArrays(inputScopes)) : [];
|
||
var filteredInput = scopeArr ? StringUtils.removeEmptyStringsFromArray(scopeArr) : [];
|
||
// Validate and filter scopes (validate function throws if validation fails)
|
||
this.validateInputScopes(filteredInput);
|
||
this.scopes = new Set(); // Iterator in constructor not supported by IE11
|
||
filteredInput.forEach(function (scope) { return _this.scopes.add(scope); });
|
||
}
|
||
/**
|
||
* Factory method to create ScopeSet from space-delimited string
|
||
* @param inputScopeString
|
||
* @param appClientId
|
||
* @param scopesRequired
|
||
*/
|
||
ScopeSet.fromString = function (inputScopeString) {
|
||
inputScopeString = inputScopeString || "";
|
||
var inputScopes = inputScopeString.split(" ");
|
||
return new ScopeSet(inputScopes);
|
||
};
|
||
/**
|
||
* Used to validate the scopes input parameter requested by the developer.
|
||
* @param {Array<string>} inputScopes - Developer requested permissions. Not all scopes are guaranteed to be included in the access token returned.
|
||
* @param {boolean} scopesRequired - Boolean indicating whether the scopes array is required or not
|
||
*/
|
||
ScopeSet.prototype.validateInputScopes = function (inputScopes) {
|
||
// Check if scopes are required but not given or is an empty array
|
||
if (!inputScopes || inputScopes.length < 1) {
|
||
throw ClientConfigurationError.createEmptyScopesArrayError(inputScopes);
|
||
}
|
||
};
|
||
/**
|
||
* Check if a given scope is present in this set of scopes.
|
||
* @param scope
|
||
*/
|
||
ScopeSet.prototype.containsScope = function (scope) {
|
||
var lowerCaseScopes = this.printScopesLowerCase().split(" ");
|
||
var lowerCaseScopesSet = new ScopeSet(lowerCaseScopes);
|
||
// compare lowercase scopes
|
||
return !StringUtils.isEmpty(scope) ? lowerCaseScopesSet.scopes.has(scope.toLowerCase()) : false;
|
||
};
|
||
/**
|
||
* Check if a set of scopes is present in this set of scopes.
|
||
* @param scopeSet
|
||
*/
|
||
ScopeSet.prototype.containsScopeSet = function (scopeSet) {
|
||
var _this = this;
|
||
if (!scopeSet || scopeSet.scopes.size <= 0) {
|
||
return false;
|
||
}
|
||
return (this.scopes.size >= scopeSet.scopes.size && scopeSet.asArray().every(function (scope) { return _this.containsScope(scope); }));
|
||
};
|
||
/**
|
||
* Check if set of scopes contains only the defaults
|
||
*/
|
||
ScopeSet.prototype.containsOnlyOIDCScopes = function () {
|
||
var _this = this;
|
||
var defaultScopeCount = 0;
|
||
OIDC_SCOPES.forEach(function (defaultScope) {
|
||
if (_this.containsScope(defaultScope)) {
|
||
defaultScopeCount += 1;
|
||
}
|
||
});
|
||
return this.scopes.size === defaultScopeCount;
|
||
};
|
||
/**
|
||
* Appends single scope if passed
|
||
* @param newScope
|
||
*/
|
||
ScopeSet.prototype.appendScope = function (newScope) {
|
||
if (!StringUtils.isEmpty(newScope)) {
|
||
this.scopes.add(newScope.trim());
|
||
}
|
||
};
|
||
/**
|
||
* Appends multiple scopes if passed
|
||
* @param newScopes
|
||
*/
|
||
ScopeSet.prototype.appendScopes = function (newScopes) {
|
||
var _this = this;
|
||
try {
|
||
newScopes.forEach(function (newScope) { return _this.appendScope(newScope); });
|
||
}
|
||
catch (e) {
|
||
throw ClientAuthError.createAppendScopeSetError(e);
|
||
}
|
||
};
|
||
/**
|
||
* Removes element from set of scopes.
|
||
* @param scope
|
||
*/
|
||
ScopeSet.prototype.removeScope = function (scope) {
|
||
if (StringUtils.isEmpty(scope)) {
|
||
throw ClientAuthError.createRemoveEmptyScopeFromSetError(scope);
|
||
}
|
||
this.scopes.delete(scope.trim());
|
||
};
|
||
/**
|
||
* Removes default scopes from set of scopes
|
||
* Primarily used to prevent cache misses if the default scopes are not returned from the server
|
||
*/
|
||
ScopeSet.prototype.removeOIDCScopes = function () {
|
||
var _this = this;
|
||
OIDC_SCOPES.forEach(function (defaultScope) {
|
||
_this.scopes.delete(defaultScope);
|
||
});
|
||
};
|
||
/**
|
||
* Combines an array of scopes with the current set of scopes.
|
||
* @param otherScopes
|
||
*/
|
||
ScopeSet.prototype.unionScopeSets = function (otherScopes) {
|
||
if (!otherScopes) {
|
||
throw ClientAuthError.createEmptyInputScopeSetError(otherScopes);
|
||
}
|
||
var unionScopes = new Set(); // Iterator in constructor not supported in IE11
|
||
otherScopes.scopes.forEach(function (scope) { return unionScopes.add(scope.toLowerCase()); });
|
||
this.scopes.forEach(function (scope) { return unionScopes.add(scope.toLowerCase()); });
|
||
return unionScopes;
|
||
};
|
||
/**
|
||
* Check if scopes intersect between this set and another.
|
||
* @param otherScopes
|
||
*/
|
||
ScopeSet.prototype.intersectingScopeSets = function (otherScopes) {
|
||
if (!otherScopes) {
|
||
throw ClientAuthError.createEmptyInputScopeSetError(otherScopes);
|
||
}
|
||
// Do not allow OIDC scopes to be the only intersecting scopes
|
||
if (!otherScopes.containsOnlyOIDCScopes()) {
|
||
otherScopes.removeOIDCScopes();
|
||
}
|
||
var unionScopes = this.unionScopeSets(otherScopes);
|
||
var sizeOtherScopes = otherScopes.getScopeCount();
|
||
var sizeThisScopes = this.getScopeCount();
|
||
var sizeUnionScopes = unionScopes.size;
|
||
return sizeUnionScopes < (sizeThisScopes + sizeOtherScopes);
|
||
};
|
||
/**
|
||
* Returns size of set of scopes.
|
||
*/
|
||
ScopeSet.prototype.getScopeCount = function () {
|
||
return this.scopes.size;
|
||
};
|
||
/**
|
||
* Returns the scopes as an array of string values
|
||
*/
|
||
ScopeSet.prototype.asArray = function () {
|
||
var array = [];
|
||
this.scopes.forEach(function (val) { return array.push(val); });
|
||
return array;
|
||
};
|
||
/**
|
||
* Prints scopes into a space-delimited string
|
||
*/
|
||
ScopeSet.prototype.printScopes = function () {
|
||
if (this.scopes) {
|
||
var scopeArr = this.asArray();
|
||
return scopeArr.join(" ");
|
||
}
|
||
return "";
|
||
};
|
||
/**
|
||
* Prints scopes into a space-delimited lower-case string (used for caching)
|
||
*/
|
||
ScopeSet.prototype.printScopesLowerCase = function () {
|
||
return this.printScopes().toLowerCase();
|
||
};
|
||
return ScopeSet;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Function to build a client info object
|
||
* @param rawClientInfo
|
||
* @param crypto
|
||
*/
|
||
function buildClientInfo(rawClientInfo, crypto) {
|
||
if (StringUtils.isEmpty(rawClientInfo)) {
|
||
throw ClientAuthError.createClientInfoEmptyError();
|
||
}
|
||
try {
|
||
var decodedClientInfo = crypto.base64Decode(rawClientInfo);
|
||
return JSON.parse(decodedClientInfo);
|
||
}
|
||
catch (e) {
|
||
throw ClientAuthError.createClientInfoDecodingError(e);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Authority types supported by MSAL.
|
||
*/
|
||
var AuthorityType;
|
||
(function (AuthorityType) {
|
||
AuthorityType[AuthorityType["Default"] = 0] = "Default";
|
||
AuthorityType[AuthorityType["Adfs"] = 1] = "Adfs";
|
||
})(AuthorityType || (AuthorityType = {}));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Type that defines required and optional parameters for an Account field (based on universal cache schema implemented by all MSALs).
|
||
*
|
||
* Key : Value Schema
|
||
*
|
||
* Key: <home_account_id>-<environment>-<realm*>
|
||
*
|
||
* Value Schema:
|
||
* {
|
||
* homeAccountId: home account identifier for the auth scheme,
|
||
* environment: entity that issued the token, represented as a full host
|
||
* realm: Full tenant or organizational identifier that the account belongs to
|
||
* localAccountId: Original tenant-specific accountID, usually used for legacy cases
|
||
* username: primary username that represents the user, usually corresponds to preferred_username in the v2 endpt
|
||
* authorityType: Accounts authority type as a string
|
||
* name: Full name for the account, including given name and family name,
|
||
* clientInfo: Full base64 encoded client info received from ESTS
|
||
* lastModificationTime: last time this entity was modified in the cache
|
||
* lastModificationApp:
|
||
* oboAssertion: access token passed in as part of OBO request
|
||
* idTokenClaims: Object containing claims parsed from ID token
|
||
* }
|
||
*/
|
||
var AccountEntity = /** @class */ (function () {
|
||
function AccountEntity() {
|
||
}
|
||
/**
|
||
* Generate Account Id key component as per the schema: <home_account_id>-<environment>
|
||
*/
|
||
AccountEntity.prototype.generateAccountId = function () {
|
||
var accountId = [this.homeAccountId, this.environment];
|
||
return accountId.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
|
||
};
|
||
/**
|
||
* Generate Account Cache Key as per the schema: <home_account_id>-<environment>-<realm*>
|
||
*/
|
||
AccountEntity.prototype.generateAccountKey = function () {
|
||
return AccountEntity.generateAccountCacheKey({
|
||
homeAccountId: this.homeAccountId,
|
||
environment: this.environment,
|
||
tenantId: this.realm,
|
||
username: this.username,
|
||
localAccountId: this.localAccountId
|
||
});
|
||
};
|
||
/**
|
||
* returns the type of the cache (in this case account)
|
||
*/
|
||
AccountEntity.prototype.generateType = function () {
|
||
switch (this.authorityType) {
|
||
case CacheAccountType.ADFS_ACCOUNT_TYPE:
|
||
return CacheType.ADFS;
|
||
case CacheAccountType.MSAV1_ACCOUNT_TYPE:
|
||
return CacheType.MSA;
|
||
case CacheAccountType.MSSTS_ACCOUNT_TYPE:
|
||
return CacheType.MSSTS;
|
||
case CacheAccountType.GENERIC_ACCOUNT_TYPE:
|
||
return CacheType.GENERIC;
|
||
default: {
|
||
throw ClientAuthError.createUnexpectedAccountTypeError();
|
||
}
|
||
}
|
||
};
|
||
/**
|
||
* Returns the AccountInfo interface for this account.
|
||
*/
|
||
AccountEntity.prototype.getAccountInfo = function () {
|
||
return {
|
||
homeAccountId: this.homeAccountId,
|
||
environment: this.environment,
|
||
tenantId: this.realm,
|
||
username: this.username,
|
||
localAccountId: this.localAccountId,
|
||
name: this.name,
|
||
idTokenClaims: this.idTokenClaims
|
||
};
|
||
};
|
||
/**
|
||
* Generates account key from interface
|
||
* @param accountInterface
|
||
*/
|
||
AccountEntity.generateAccountCacheKey = function (accountInterface) {
|
||
var accountKey = [
|
||
accountInterface.homeAccountId,
|
||
accountInterface.environment || "",
|
||
accountInterface.tenantId || "",
|
||
];
|
||
return accountKey.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
|
||
};
|
||
/**
|
||
* Build Account cache from IdToken, clientInfo and authority/policy. Associated with AAD.
|
||
* @param clientInfo
|
||
* @param authority
|
||
* @param idToken
|
||
* @param policy
|
||
*/
|
||
AccountEntity.createAccount = function (clientInfo, homeAccountId, authority, idToken, oboAssertion, cloudGraphHostName, msGraphHost) {
|
||
var _a, _b, _c, _d, _e, _f;
|
||
var account = new AccountEntity();
|
||
account.authorityType = CacheAccountType.MSSTS_ACCOUNT_TYPE;
|
||
account.clientInfo = clientInfo;
|
||
account.homeAccountId = homeAccountId;
|
||
var env = authority.getPreferredCache();
|
||
if (StringUtils.isEmpty(env)) {
|
||
throw ClientAuthError.createInvalidCacheEnvironmentError();
|
||
}
|
||
account.environment = env;
|
||
// non AAD scenarios can have empty realm
|
||
account.realm = ((_a = idToken === null || idToken === void 0 ? void 0 : idToken.claims) === null || _a === void 0 ? void 0 : _a.tid) || "";
|
||
account.oboAssertion = oboAssertion;
|
||
if (idToken) {
|
||
account.idTokenClaims = idToken.claims;
|
||
// How do you account for MSA CID here?
|
||
account.localAccountId = ((_b = idToken === null || idToken === void 0 ? void 0 : idToken.claims) === null || _b === void 0 ? void 0 : _b.oid) || ((_c = idToken === null || idToken === void 0 ? void 0 : idToken.claims) === null || _c === void 0 ? void 0 : _c.sub) || "";
|
||
/*
|
||
* In B2C scenarios the emails claim is used instead of preferred_username and it is an array. In most cases it will contain a single email.
|
||
* This field should not be relied upon if a custom policy is configured to return more than 1 email.
|
||
*/
|
||
account.username = ((_d = idToken === null || idToken === void 0 ? void 0 : idToken.claims) === null || _d === void 0 ? void 0 : _d.preferred_username) || (((_e = idToken === null || idToken === void 0 ? void 0 : idToken.claims) === null || _e === void 0 ? void 0 : _e.emails) ? idToken.claims.emails[0] : "");
|
||
account.name = (_f = idToken === null || idToken === void 0 ? void 0 : idToken.claims) === null || _f === void 0 ? void 0 : _f.name;
|
||
}
|
||
account.cloudGraphHostName = cloudGraphHostName;
|
||
account.msGraphHost = msGraphHost;
|
||
return account;
|
||
};
|
||
/**
|
||
* Builds non-AAD/ADFS account.
|
||
* @param authority
|
||
* @param idToken
|
||
*/
|
||
AccountEntity.createGenericAccount = function (authority, homeAccountId, idToken, oboAssertion, cloudGraphHostName, msGraphHost) {
|
||
var _a, _b, _c, _d;
|
||
var account = new AccountEntity();
|
||
account.authorityType = (authority.authorityType === AuthorityType.Adfs) ? CacheAccountType.ADFS_ACCOUNT_TYPE : CacheAccountType.GENERIC_ACCOUNT_TYPE;
|
||
account.homeAccountId = homeAccountId;
|
||
// non AAD scenarios can have empty realm
|
||
account.realm = "";
|
||
account.oboAssertion = oboAssertion;
|
||
var env = authority.getPreferredCache();
|
||
if (StringUtils.isEmpty(env)) {
|
||
throw ClientAuthError.createInvalidCacheEnvironmentError();
|
||
}
|
||
if (idToken) {
|
||
// How do you account for MSA CID here?
|
||
account.localAccountId = ((_a = idToken === null || idToken === void 0 ? void 0 : idToken.claims) === null || _a === void 0 ? void 0 : _a.oid) || ((_b = idToken === null || idToken === void 0 ? void 0 : idToken.claims) === null || _b === void 0 ? void 0 : _b.sub) || "";
|
||
// upn claim for most ADFS scenarios
|
||
account.username = ((_c = idToken === null || idToken === void 0 ? void 0 : idToken.claims) === null || _c === void 0 ? void 0 : _c.upn) || "";
|
||
account.name = ((_d = idToken === null || idToken === void 0 ? void 0 : idToken.claims) === null || _d === void 0 ? void 0 : _d.name) || "";
|
||
account.idTokenClaims = idToken === null || idToken === void 0 ? void 0 : idToken.claims;
|
||
}
|
||
account.environment = env;
|
||
account.cloudGraphHostName = cloudGraphHostName;
|
||
account.msGraphHost = msGraphHost;
|
||
/*
|
||
* add uniqueName to claims
|
||
* account.name = idToken.claims.uniqueName;
|
||
*/
|
||
return account;
|
||
};
|
||
/**
|
||
* Generate HomeAccountId from server response
|
||
* @param serverClientInfo
|
||
* @param authType
|
||
*/
|
||
AccountEntity.generateHomeAccountId = function (serverClientInfo, authType, logger, cryptoObj, idToken) {
|
||
var _a;
|
||
var accountId = ((_a = idToken === null || idToken === void 0 ? void 0 : idToken.claims) === null || _a === void 0 ? void 0 : _a.sub) ? idToken.claims.sub : Constants.EMPTY_STRING;
|
||
// since ADFS does not have tid and does not set client_info
|
||
if (authType === AuthorityType.Adfs) {
|
||
return accountId;
|
||
}
|
||
// for cases where there is clientInfo
|
||
if (serverClientInfo) {
|
||
var clientInfo = buildClientInfo(serverClientInfo, cryptoObj);
|
||
if (!StringUtils.isEmpty(clientInfo.uid) && !StringUtils.isEmpty(clientInfo.utid)) {
|
||
return "" + clientInfo.uid + Separators.CLIENT_INFO_SEPARATOR + clientInfo.utid;
|
||
}
|
||
}
|
||
// default to "sub" claim
|
||
logger.verbose("No client info in response");
|
||
return accountId;
|
||
};
|
||
/**
|
||
* Validates an entity: checks for all expected params
|
||
* @param entity
|
||
*/
|
||
AccountEntity.isAccountEntity = function (entity) {
|
||
if (!entity) {
|
||
return false;
|
||
}
|
||
return (entity.hasOwnProperty("homeAccountId") &&
|
||
entity.hasOwnProperty("environment") &&
|
||
entity.hasOwnProperty("realm") &&
|
||
entity.hasOwnProperty("localAccountId") &&
|
||
entity.hasOwnProperty("username") &&
|
||
entity.hasOwnProperty("authorityType"));
|
||
};
|
||
/**
|
||
* Helper function to determine whether 2 accounts are equal
|
||
* Used to avoid unnecessary state updates
|
||
* @param arrayA
|
||
* @param arrayB
|
||
*/
|
||
AccountEntity.accountInfoIsEqual = function (accountA, accountB) {
|
||
if (!accountA || !accountB) {
|
||
return false;
|
||
}
|
||
return (accountA.homeAccountId === accountB.homeAccountId) &&
|
||
(accountA.localAccountId === accountB.localAccountId) &&
|
||
(accountA.username === accountB.username) &&
|
||
(accountA.tenantId === accountB.tenantId) &&
|
||
(accountA.environment === accountB.environment);
|
||
};
|
||
return AccountEntity;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* JWT Token representation class. Parses token string and generates claims object.
|
||
*/
|
||
var AuthToken = /** @class */ (function () {
|
||
function AuthToken(rawToken, crypto) {
|
||
if (StringUtils.isEmpty(rawToken)) {
|
||
throw ClientAuthError.createTokenNullOrEmptyError(rawToken);
|
||
}
|
||
this.rawToken = rawToken;
|
||
this.claims = AuthToken.extractTokenClaims(rawToken, crypto);
|
||
}
|
||
/**
|
||
* Extract token by decoding the rawToken
|
||
*
|
||
* @param encodedToken
|
||
*/
|
||
AuthToken.extractTokenClaims = function (encodedToken, crypto) {
|
||
var decodedToken = StringUtils.decodeAuthToken(encodedToken);
|
||
// token will be decoded to get the username
|
||
try {
|
||
var base64TokenPayload = decodedToken.JWSPayload;
|
||
// base64Decode() should throw an error if there is an issue
|
||
var base64Decoded = crypto.base64Decode(base64TokenPayload);
|
||
return JSON.parse(base64Decoded);
|
||
}
|
||
catch (err) {
|
||
throw ClientAuthError.createTokenParsingError(err);
|
||
}
|
||
};
|
||
return AuthToken;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Interface class which implement cache storage functions used by MSAL to perform validity checks, and store tokens.
|
||
*/
|
||
var CacheManager = /** @class */ (function () {
|
||
function CacheManager(clientId, cryptoImpl) {
|
||
this.clientId = clientId;
|
||
this.cryptoImpl = cryptoImpl;
|
||
}
|
||
/**
|
||
* Returns all accounts in cache
|
||
*/
|
||
CacheManager.prototype.getAllAccounts = function () {
|
||
var _this = this;
|
||
var currentAccounts = this.getAccountsFilteredBy();
|
||
var accountValues = Object.keys(currentAccounts).map(function (accountKey) { return currentAccounts[accountKey]; });
|
||
var numAccounts = accountValues.length;
|
||
if (numAccounts < 1) {
|
||
return [];
|
||
}
|
||
else {
|
||
var allAccounts = accountValues.map(function (value) {
|
||
var accountEntity = CacheManager.toObject(new AccountEntity(), value);
|
||
var accountInfo = accountEntity.getAccountInfo();
|
||
var idToken = _this.readIdTokenFromCache(_this.clientId, accountInfo);
|
||
if (idToken && !accountInfo.idTokenClaims) {
|
||
accountInfo.idTokenClaims = new AuthToken(idToken.secret, _this.cryptoImpl).claims;
|
||
}
|
||
return accountInfo;
|
||
});
|
||
return allAccounts;
|
||
}
|
||
};
|
||
/**
|
||
* saves a cache record
|
||
* @param cacheRecord
|
||
*/
|
||
CacheManager.prototype.saveCacheRecord = function (cacheRecord) {
|
||
if (!cacheRecord) {
|
||
throw ClientAuthError.createNullOrUndefinedCacheRecord();
|
||
}
|
||
if (!!cacheRecord.account) {
|
||
this.setAccount(cacheRecord.account);
|
||
}
|
||
if (!!cacheRecord.idToken) {
|
||
this.setIdTokenCredential(cacheRecord.idToken);
|
||
}
|
||
if (!!cacheRecord.accessToken) {
|
||
this.saveAccessToken(cacheRecord.accessToken);
|
||
}
|
||
if (!!cacheRecord.refreshToken) {
|
||
this.setRefreshTokenCredential(cacheRecord.refreshToken);
|
||
}
|
||
if (!!cacheRecord.appMetadata) {
|
||
this.setAppMetadata(cacheRecord.appMetadata);
|
||
}
|
||
};
|
||
/**
|
||
* saves access token credential
|
||
* @param credential
|
||
*/
|
||
CacheManager.prototype.saveAccessToken = function (credential) {
|
||
var _this = this;
|
||
var currentTokenCache = this.getCredentialsFilteredBy({
|
||
clientId: credential.clientId,
|
||
credentialType: CredentialType.ACCESS_TOKEN,
|
||
environment: credential.environment,
|
||
homeAccountId: credential.homeAccountId,
|
||
realm: credential.realm,
|
||
});
|
||
var currentScopes = ScopeSet.fromString(credential.target);
|
||
var currentAccessTokens = Object.keys(currentTokenCache.accessTokens).map(function (key) { return currentTokenCache.accessTokens[key]; });
|
||
if (currentAccessTokens) {
|
||
currentAccessTokens.forEach(function (tokenEntity) {
|
||
var tokenScopeSet = ScopeSet.fromString(tokenEntity.target);
|
||
if (tokenScopeSet.intersectingScopeSets(currentScopes)) {
|
||
_this.removeCredential(tokenEntity);
|
||
}
|
||
});
|
||
}
|
||
this.setAccessTokenCredential(credential);
|
||
};
|
||
/**
|
||
* retrieve accounts matching all provided filters; if no filter is set, get all accounts
|
||
* not checking for casing as keys are all generated in lower case, remember to convert to lower case if object properties are compared
|
||
* @param homeAccountId
|
||
* @param environment
|
||
* @param realm
|
||
*/
|
||
CacheManager.prototype.getAccountsFilteredBy = function (accountFilter) {
|
||
return this.getAccountsFilteredByInternal(accountFilter ? accountFilter.homeAccountId : "", accountFilter ? accountFilter.environment : "", accountFilter ? accountFilter.realm : "");
|
||
};
|
||
/**
|
||
* retrieve accounts matching all provided filters; if no filter is set, get all accounts
|
||
* not checking for casing as keys are all generated in lower case, remember to convert to lower case if object properties are compared
|
||
* @param homeAccountId
|
||
* @param environment
|
||
* @param realm
|
||
*/
|
||
CacheManager.prototype.getAccountsFilteredByInternal = function (homeAccountId, environment, realm) {
|
||
var _this = this;
|
||
var allCacheKeys = this.getKeys();
|
||
var matchingAccounts = {};
|
||
allCacheKeys.forEach(function (cacheKey) {
|
||
var entity = _this.getAccount(cacheKey);
|
||
if (!entity) {
|
||
return;
|
||
}
|
||
if (!!homeAccountId && !_this.matchHomeAccountId(entity, homeAccountId)) {
|
||
return;
|
||
}
|
||
if (!!environment && !_this.matchEnvironment(entity, environment)) {
|
||
return;
|
||
}
|
||
if (!!realm && !_this.matchRealm(entity, realm)) {
|
||
return;
|
||
}
|
||
matchingAccounts[cacheKey] = entity;
|
||
});
|
||
return matchingAccounts;
|
||
};
|
||
/**
|
||
* retrieve credentails matching all provided filters; if no filter is set, get all credentials
|
||
* @param homeAccountId
|
||
* @param environment
|
||
* @param credentialType
|
||
* @param clientId
|
||
* @param realm
|
||
* @param target
|
||
*/
|
||
CacheManager.prototype.getCredentialsFilteredBy = function (filter) {
|
||
return this.getCredentialsFilteredByInternal(filter.homeAccountId, filter.environment, filter.credentialType, filter.clientId, filter.familyId, filter.realm, filter.target, filter.oboAssertion);
|
||
};
|
||
/**
|
||
* Support function to help match credentials
|
||
* @param homeAccountId
|
||
* @param environment
|
||
* @param credentialType
|
||
* @param clientId
|
||
* @param realm
|
||
* @param target
|
||
*/
|
||
CacheManager.prototype.getCredentialsFilteredByInternal = function (homeAccountId, environment, credentialType, clientId, familyId, realm, target, oboAssertion) {
|
||
var _this = this;
|
||
var allCacheKeys = this.getKeys();
|
||
var matchingCredentials = {
|
||
idTokens: {},
|
||
accessTokens: {},
|
||
refreshTokens: {},
|
||
};
|
||
allCacheKeys.forEach(function (cacheKey) {
|
||
// don't parse any non-credential type cache entities
|
||
var credType = CredentialEntity.getCredentialType(cacheKey);
|
||
if (credType === Constants.NOT_DEFINED) {
|
||
return;
|
||
}
|
||
// Attempt retrieval
|
||
var entity = _this.getSpecificCredential(cacheKey, credType);
|
||
if (!entity) {
|
||
return;
|
||
}
|
||
if (!!oboAssertion && !_this.matchOboAssertion(entity, oboAssertion)) {
|
||
return;
|
||
}
|
||
if (!!homeAccountId && !_this.matchHomeAccountId(entity, homeAccountId)) {
|
||
return;
|
||
}
|
||
if (!!environment && !_this.matchEnvironment(entity, environment)) {
|
||
return;
|
||
}
|
||
if (!!realm && !_this.matchRealm(entity, realm)) {
|
||
return;
|
||
}
|
||
if (!!credentialType && !_this.matchCredentialType(entity, credentialType)) {
|
||
return;
|
||
}
|
||
if (!!clientId && !_this.matchClientId(entity, clientId)) {
|
||
return;
|
||
}
|
||
if (!!familyId && !_this.matchFamilyId(entity, familyId)) {
|
||
return;
|
||
}
|
||
/*
|
||
* idTokens do not have "target", target specific refreshTokens do exist for some types of authentication
|
||
* Resource specific refresh tokens case will be added when the support is deemed necessary
|
||
*/
|
||
if (!!target && !_this.matchTarget(entity, target)) {
|
||
return;
|
||
}
|
||
switch (credType) {
|
||
case CredentialType.ID_TOKEN:
|
||
matchingCredentials.idTokens[cacheKey] = entity;
|
||
break;
|
||
case CredentialType.ACCESS_TOKEN:
|
||
matchingCredentials.accessTokens[cacheKey] = entity;
|
||
break;
|
||
case CredentialType.REFRESH_TOKEN:
|
||
matchingCredentials.refreshTokens[cacheKey] = entity;
|
||
break;
|
||
}
|
||
});
|
||
return matchingCredentials;
|
||
};
|
||
/**
|
||
* retrieve appMetadata matching all provided filters; if no filter is set, get all appMetadata
|
||
* @param filter
|
||
*/
|
||
CacheManager.prototype.getAppMetadataFilteredBy = function (filter) {
|
||
return this.getAppMetadataFilteredByInternal(filter.environment, filter.clientId);
|
||
};
|
||
/**
|
||
* Support function to help match appMetadata
|
||
* @param environment
|
||
* @param clientId
|
||
*/
|
||
CacheManager.prototype.getAppMetadataFilteredByInternal = function (environment, clientId) {
|
||
var _this = this;
|
||
var allCacheKeys = this.getKeys();
|
||
var matchingAppMetadata = {};
|
||
allCacheKeys.forEach(function (cacheKey) {
|
||
// don't parse any non-appMetadata type cache entities
|
||
if (!_this.isAppMetadata(cacheKey)) {
|
||
return;
|
||
}
|
||
// Attempt retrieval
|
||
var entity = _this.getAppMetadata(cacheKey);
|
||
if (!entity) {
|
||
return;
|
||
}
|
||
if (!!environment && !_this.matchEnvironment(entity, environment)) {
|
||
return;
|
||
}
|
||
if (!!clientId && !_this.matchClientId(entity, clientId)) {
|
||
return;
|
||
}
|
||
matchingAppMetadata[cacheKey] = entity;
|
||
});
|
||
return matchingAppMetadata;
|
||
};
|
||
/**
|
||
* retrieve authorityMetadata that contains a matching alias
|
||
* @param filter
|
||
*/
|
||
CacheManager.prototype.getAuthorityMetadataByAlias = function (host) {
|
||
var _this = this;
|
||
var allCacheKeys = this.getAuthorityMetadataKeys();
|
||
var matchedEntity = null;
|
||
allCacheKeys.forEach(function (cacheKey) {
|
||
// don't parse any non-authorityMetadata type cache entities
|
||
if (!_this.isAuthorityMetadata(cacheKey) || cacheKey.indexOf(_this.clientId) === -1) {
|
||
return;
|
||
}
|
||
// Attempt retrieval
|
||
var entity = _this.getAuthorityMetadata(cacheKey);
|
||
if (!entity) {
|
||
return;
|
||
}
|
||
if (entity.aliases.indexOf(host) === -1) {
|
||
return;
|
||
}
|
||
matchedEntity = entity;
|
||
});
|
||
return matchedEntity;
|
||
};
|
||
/**
|
||
* Removes all accounts and related tokens from cache.
|
||
*/
|
||
CacheManager.prototype.removeAllAccounts = function () {
|
||
var _this = this;
|
||
var allCacheKeys = this.getKeys();
|
||
allCacheKeys.forEach(function (cacheKey) {
|
||
var entity = _this.getAccount(cacheKey);
|
||
if (!entity) {
|
||
return;
|
||
}
|
||
_this.removeAccount(cacheKey);
|
||
});
|
||
return true;
|
||
};
|
||
/**
|
||
* returns a boolean if the given account is removed
|
||
* @param account
|
||
*/
|
||
CacheManager.prototype.removeAccount = function (accountKey) {
|
||
var account = this.getAccount(accountKey);
|
||
if (!account) {
|
||
throw ClientAuthError.createNoAccountFoundError();
|
||
}
|
||
return (this.removeAccountContext(account) && this.removeItem(accountKey, CacheSchemaType.ACCOUNT));
|
||
};
|
||
/**
|
||
* returns a boolean if the given account is removed
|
||
* @param account
|
||
*/
|
||
CacheManager.prototype.removeAccountContext = function (account) {
|
||
var _this = this;
|
||
var allCacheKeys = this.getKeys();
|
||
var accountId = account.generateAccountId();
|
||
allCacheKeys.forEach(function (cacheKey) {
|
||
// don't parse any non-credential type cache entities
|
||
var credType = CredentialEntity.getCredentialType(cacheKey);
|
||
if (credType === Constants.NOT_DEFINED) {
|
||
return;
|
||
}
|
||
var cacheEntity = _this.getSpecificCredential(cacheKey, credType);
|
||
if (!!cacheEntity && accountId === cacheEntity.generateAccountId()) {
|
||
_this.removeCredential(cacheEntity);
|
||
}
|
||
});
|
||
return true;
|
||
};
|
||
/**
|
||
* returns a boolean if the given credential is removed
|
||
* @param credential
|
||
*/
|
||
CacheManager.prototype.removeCredential = function (credential) {
|
||
var key = credential.generateCredentialKey();
|
||
return this.removeItem(key, CacheSchemaType.CREDENTIAL);
|
||
};
|
||
/**
|
||
* Removes all app metadata objects from cache.
|
||
*/
|
||
CacheManager.prototype.removeAppMetadata = function () {
|
||
var _this = this;
|
||
var allCacheKeys = this.getKeys();
|
||
allCacheKeys.forEach(function (cacheKey) {
|
||
if (_this.isAppMetadata(cacheKey)) {
|
||
_this.removeItem(cacheKey, CacheSchemaType.APP_METADATA);
|
||
}
|
||
});
|
||
return true;
|
||
};
|
||
/**
|
||
* Retrieve the cached credentials into a cacherecord
|
||
* @param account
|
||
* @param clientId
|
||
* @param scopes
|
||
* @param environment
|
||
*/
|
||
CacheManager.prototype.readCacheRecord = function (account, clientId, scopes, environment) {
|
||
var cachedAccount = this.readAccountFromCache(account);
|
||
var cachedIdToken = this.readIdTokenFromCache(clientId, account);
|
||
var cachedAccessToken = this.readAccessTokenFromCache(clientId, account, scopes);
|
||
var cachedRefreshToken = this.readRefreshTokenFromCache(clientId, account, false);
|
||
var cachedAppMetadata = this.readAppMetadataFromCache(environment, clientId);
|
||
if (cachedAccount && cachedIdToken) {
|
||
cachedAccount.idTokenClaims = new AuthToken(cachedIdToken.secret, this.cryptoImpl).claims;
|
||
}
|
||
return {
|
||
account: cachedAccount,
|
||
idToken: cachedIdToken,
|
||
accessToken: cachedAccessToken,
|
||
refreshToken: cachedRefreshToken,
|
||
appMetadata: cachedAppMetadata,
|
||
};
|
||
};
|
||
/**
|
||
* Retrieve AccountEntity from cache
|
||
* @param account
|
||
*/
|
||
CacheManager.prototype.readAccountFromCache = function (account) {
|
||
var accountKey = AccountEntity.generateAccountCacheKey(account);
|
||
return this.getAccount(accountKey);
|
||
};
|
||
/**
|
||
* Retrieve IdTokenEntity from cache
|
||
* @param clientId
|
||
* @param account
|
||
* @param inputRealm
|
||
*/
|
||
CacheManager.prototype.readIdTokenFromCache = function (clientId, account) {
|
||
var idTokenFilter = {
|
||
homeAccountId: account.homeAccountId,
|
||
environment: account.environment,
|
||
credentialType: CredentialType.ID_TOKEN,
|
||
clientId: clientId,
|
||
realm: account.tenantId,
|
||
};
|
||
var credentialCache = this.getCredentialsFilteredBy(idTokenFilter);
|
||
var idTokens = Object.keys(credentialCache.idTokens).map(function (key) { return credentialCache.idTokens[key]; });
|
||
var numIdTokens = idTokens.length;
|
||
if (numIdTokens < 1) {
|
||
return null;
|
||
}
|
||
else if (numIdTokens > 1) {
|
||
throw ClientAuthError.createMultipleMatchingTokensInCacheError();
|
||
}
|
||
return idTokens[0];
|
||
};
|
||
/**
|
||
* Retrieve AccessTokenEntity from cache
|
||
* @param clientId
|
||
* @param account
|
||
* @param scopes
|
||
* @param inputRealm
|
||
*/
|
||
CacheManager.prototype.readAccessTokenFromCache = function (clientId, account, scopes) {
|
||
var accessTokenFilter = {
|
||
homeAccountId: account.homeAccountId,
|
||
environment: account.environment,
|
||
credentialType: CredentialType.ACCESS_TOKEN,
|
||
clientId: clientId,
|
||
realm: account.tenantId,
|
||
target: scopes.printScopesLowerCase(),
|
||
};
|
||
var credentialCache = this.getCredentialsFilteredBy(accessTokenFilter);
|
||
var accessTokens = Object.keys(credentialCache.accessTokens).map(function (key) { return credentialCache.accessTokens[key]; });
|
||
var numAccessTokens = accessTokens.length;
|
||
if (numAccessTokens < 1) {
|
||
return null;
|
||
}
|
||
else if (numAccessTokens > 1) {
|
||
throw ClientAuthError.createMultipleMatchingTokensInCacheError();
|
||
}
|
||
return accessTokens[0];
|
||
};
|
||
/**
|
||
* Helper to retrieve the appropriate refresh token from cache
|
||
* @param clientId
|
||
* @param account
|
||
* @param familyRT
|
||
*/
|
||
CacheManager.prototype.readRefreshTokenFromCache = function (clientId, account, familyRT) {
|
||
var id = familyRT ? THE_FAMILY_ID : undefined;
|
||
var refreshTokenFilter = {
|
||
homeAccountId: account.homeAccountId,
|
||
environment: account.environment,
|
||
credentialType: CredentialType.REFRESH_TOKEN,
|
||
clientId: clientId,
|
||
familyId: id
|
||
};
|
||
var credentialCache = this.getCredentialsFilteredBy(refreshTokenFilter);
|
||
var refreshTokens = Object.keys(credentialCache.refreshTokens).map(function (key) { return credentialCache.refreshTokens[key]; });
|
||
var numRefreshTokens = refreshTokens.length;
|
||
if (numRefreshTokens < 1) {
|
||
return null;
|
||
}
|
||
// address the else case after remove functions address environment aliases
|
||
return refreshTokens[0];
|
||
};
|
||
/**
|
||
* Retrieve AppMetadataEntity from cache
|
||
*/
|
||
CacheManager.prototype.readAppMetadataFromCache = function (environment, clientId) {
|
||
var appMetadataFilter = {
|
||
environment: environment,
|
||
clientId: clientId,
|
||
};
|
||
var appMetadata = this.getAppMetadataFilteredBy(appMetadataFilter);
|
||
var appMetadataEntries = Object.keys(appMetadata).map(function (key) { return appMetadata[key]; });
|
||
var numAppMetadata = appMetadataEntries.length;
|
||
if (numAppMetadata < 1) {
|
||
return null;
|
||
}
|
||
else if (numAppMetadata > 1) {
|
||
throw ClientAuthError.createMultipleMatchingAppMetadataInCacheError();
|
||
}
|
||
return appMetadataEntries[0];
|
||
};
|
||
/**
|
||
* Return the family_id value associated with FOCI
|
||
* @param environment
|
||
* @param clientId
|
||
*/
|
||
CacheManager.prototype.isAppMetadataFOCI = function (environment, clientId) {
|
||
var appMetadata = this.readAppMetadataFromCache(environment, clientId);
|
||
return !!(appMetadata && appMetadata.familyId === THE_FAMILY_ID);
|
||
};
|
||
/**
|
||
* helper to match account ids
|
||
* @param value
|
||
* @param homeAccountId
|
||
*/
|
||
CacheManager.prototype.matchHomeAccountId = function (entity, homeAccountId) {
|
||
return !!(entity.homeAccountId && homeAccountId === entity.homeAccountId);
|
||
};
|
||
/**
|
||
* helper to match assertion
|
||
* @param value
|
||
* @param oboAssertion
|
||
*/
|
||
CacheManager.prototype.matchOboAssertion = function (entity, oboAssertion) {
|
||
return !!(entity.oboAssertion && oboAssertion === entity.oboAssertion);
|
||
};
|
||
/**
|
||
* helper to match environment
|
||
* @param value
|
||
* @param environment
|
||
*/
|
||
CacheManager.prototype.matchEnvironment = function (entity, environment) {
|
||
var cloudMetadata = this.getAuthorityMetadataByAlias(environment);
|
||
if (cloudMetadata && cloudMetadata.aliases.indexOf(entity.environment) > -1) {
|
||
return true;
|
||
}
|
||
return false;
|
||
};
|
||
/**
|
||
* helper to match credential type
|
||
* @param entity
|
||
* @param credentialType
|
||
*/
|
||
CacheManager.prototype.matchCredentialType = function (entity, credentialType) {
|
||
return (entity.credentialType && credentialType.toLowerCase() === entity.credentialType.toLowerCase());
|
||
};
|
||
/**
|
||
* helper to match client ids
|
||
* @param entity
|
||
* @param clientId
|
||
*/
|
||
CacheManager.prototype.matchClientId = function (entity, clientId) {
|
||
return !!(entity.clientId && clientId === entity.clientId);
|
||
};
|
||
/**
|
||
* helper to match family ids
|
||
* @param entity
|
||
* @param familyId
|
||
*/
|
||
CacheManager.prototype.matchFamilyId = function (entity, familyId) {
|
||
return !!(entity.familyId && familyId === entity.familyId);
|
||
};
|
||
/**
|
||
* helper to match realm
|
||
* @param entity
|
||
* @param realm
|
||
*/
|
||
CacheManager.prototype.matchRealm = function (entity, realm) {
|
||
return !!(entity.realm && realm === entity.realm);
|
||
};
|
||
/**
|
||
* Returns true if the target scopes are a subset of the current entity's scopes, false otherwise.
|
||
* @param entity
|
||
* @param target
|
||
*/
|
||
CacheManager.prototype.matchTarget = function (entity, target) {
|
||
if (entity.credentialType !== CredentialType.ACCESS_TOKEN || !entity.target) {
|
||
return false;
|
||
}
|
||
var entityScopeSet = ScopeSet.fromString(entity.target);
|
||
var requestTargetScopeSet = ScopeSet.fromString(target);
|
||
if (!requestTargetScopeSet.containsOnlyOIDCScopes()) {
|
||
requestTargetScopeSet.removeOIDCScopes(); // ignore OIDC scopes
|
||
}
|
||
return entityScopeSet.containsScopeSet(requestTargetScopeSet);
|
||
};
|
||
/**
|
||
* returns if a given cache entity is of the type appmetadata
|
||
* @param key
|
||
*/
|
||
CacheManager.prototype.isAppMetadata = function (key) {
|
||
return key.indexOf(APP_METADATA) !== -1;
|
||
};
|
||
/**
|
||
* returns if a given cache entity is of the type authoritymetadata
|
||
* @param key
|
||
*/
|
||
CacheManager.prototype.isAuthorityMetadata = function (key) {
|
||
return key.indexOf(AUTHORITY_METADATA_CONSTANTS.CACHE_KEY) !== -1;
|
||
};
|
||
/**
|
||
* returns cache key used for cloud instance metadata
|
||
*/
|
||
CacheManager.prototype.generateAuthorityMetadataCacheKey = function (authority) {
|
||
return AUTHORITY_METADATA_CONSTANTS.CACHE_KEY + "-" + this.clientId + "-" + authority;
|
||
};
|
||
/**
|
||
* Returns the specific credential (IdToken/AccessToken/RefreshToken) from the cache
|
||
* @param key
|
||
* @param credType
|
||
*/
|
||
CacheManager.prototype.getSpecificCredential = function (key, credType) {
|
||
switch (credType) {
|
||
case CredentialType.ID_TOKEN: {
|
||
return this.getIdTokenCredential(key);
|
||
}
|
||
case CredentialType.ACCESS_TOKEN: {
|
||
return this.getAccessTokenCredential(key);
|
||
}
|
||
case CredentialType.REFRESH_TOKEN: {
|
||
return this.getRefreshTokenCredential(key);
|
||
}
|
||
default:
|
||
return null;
|
||
}
|
||
};
|
||
/**
|
||
* Helper to convert serialized data to object
|
||
* @param obj
|
||
* @param json
|
||
*/
|
||
CacheManager.toObject = function (obj, json) {
|
||
for (var propertyName in json) {
|
||
obj[propertyName] = json[propertyName];
|
||
}
|
||
return obj;
|
||
};
|
||
return CacheManager;
|
||
}());
|
||
var DefaultStorageClass = /** @class */ (function (_super) {
|
||
__extends(DefaultStorageClass, _super);
|
||
function DefaultStorageClass() {
|
||
return _super !== null && _super.apply(this, arguments) || this;
|
||
}
|
||
DefaultStorageClass.prototype.setAccount = function () {
|
||
var notImplErr = "Storage interface - setAccount() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.getAccount = function () {
|
||
var notImplErr = "Storage interface - getAccount() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.setIdTokenCredential = function () {
|
||
var notImplErr = "Storage interface - setIdTokenCredential() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.getIdTokenCredential = function () {
|
||
var notImplErr = "Storage interface - getIdTokenCredential() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.setAccessTokenCredential = function () {
|
||
var notImplErr = "Storage interface - setAccessTokenCredential() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.getAccessTokenCredential = function () {
|
||
var notImplErr = "Storage interface - getAccessTokenCredential() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.setRefreshTokenCredential = function () {
|
||
var notImplErr = "Storage interface - setRefreshTokenCredential() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.getRefreshTokenCredential = function () {
|
||
var notImplErr = "Storage interface - getRefreshTokenCredential() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.setAppMetadata = function () {
|
||
var notImplErr = "Storage interface - setAppMetadata() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.getAppMetadata = function () {
|
||
var notImplErr = "Storage interface - getAppMetadata() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.setServerTelemetry = function () {
|
||
var notImplErr = "Storage interface - setServerTelemetry() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.getServerTelemetry = function () {
|
||
var notImplErr = "Storage interface - getServerTelemetry() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.setAuthorityMetadata = function () {
|
||
var notImplErr = "Storage interface - setAuthorityMetadata() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.getAuthorityMetadata = function () {
|
||
var notImplErr = "Storage interface - getAuthorityMetadata() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.getAuthorityMetadataKeys = function () {
|
||
var notImplErr = "Storage interface - getAuthorityMetadataKeys() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.setThrottlingCache = function () {
|
||
var notImplErr = "Storage interface - setThrottlingCache() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.getThrottlingCache = function () {
|
||
var notImplErr = "Storage interface - getThrottlingCache() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.removeItem = function () {
|
||
var notImplErr = "Storage interface - removeItem() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.containsKey = function () {
|
||
var notImplErr = "Storage interface - containsKey() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.getKeys = function () {
|
||
var notImplErr = "Storage interface - getKeys() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
DefaultStorageClass.prototype.clear = function () {
|
||
var notImplErr = "Storage interface - clear() has not been implemented for the cacheStorage interface.";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
};
|
||
return DefaultStorageClass;
|
||
}(CacheManager));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
// Token renewal offset default in seconds
|
||
var DEFAULT_TOKEN_RENEWAL_OFFSET_SEC = 300;
|
||
var DEFAULT_SYSTEM_OPTIONS = {
|
||
tokenRenewalOffsetSeconds: DEFAULT_TOKEN_RENEWAL_OFFSET_SEC
|
||
};
|
||
var DEFAULT_LOGGER_IMPLEMENTATION = {
|
||
loggerCallback: function () {
|
||
// allow users to not set loggerCallback
|
||
},
|
||
piiLoggingEnabled: false,
|
||
logLevel: LogLevel.Info
|
||
};
|
||
var DEFAULT_NETWORK_IMPLEMENTATION = {
|
||
sendGetRequestAsync: function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var notImplErr;
|
||
return __generator(this, function (_a) {
|
||
notImplErr = "Network interface - sendGetRequestAsync() has not been implemented";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
});
|
||
});
|
||
},
|
||
sendPostRequestAsync: function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var notImplErr;
|
||
return __generator(this, function (_a) {
|
||
notImplErr = "Network interface - sendPostRequestAsync() has not been implemented";
|
||
throw AuthError.createUnexpectedError(notImplErr);
|
||
});
|
||
});
|
||
}
|
||
};
|
||
var DEFAULT_LIBRARY_INFO = {
|
||
sku: Constants.SKU,
|
||
version: version,
|
||
cpu: "",
|
||
os: ""
|
||
};
|
||
var DEFAULT_CLIENT_CREDENTIALS = {
|
||
clientSecret: "",
|
||
clientAssertion: undefined
|
||
};
|
||
/**
|
||
* Function that sets the default options when not explicitly configured from app developer
|
||
*
|
||
* @param Configuration
|
||
*
|
||
* @returns Configuration
|
||
*/
|
||
function buildClientConfiguration(_a) {
|
||
var userAuthOptions = _a.authOptions, userSystemOptions = _a.systemOptions, userLoggerOption = _a.loggerOptions, storageImplementation = _a.storageInterface, networkImplementation = _a.networkInterface, cryptoImplementation = _a.cryptoInterface, clientCredentials = _a.clientCredentials, libraryInfo = _a.libraryInfo, serverTelemetryManager = _a.serverTelemetryManager, persistencePlugin = _a.persistencePlugin, serializableCache = _a.serializableCache;
|
||
return {
|
||
authOptions: buildAuthOptions(userAuthOptions),
|
||
systemOptions: __assign(__assign({}, DEFAULT_SYSTEM_OPTIONS), userSystemOptions),
|
||
loggerOptions: __assign(__assign({}, DEFAULT_LOGGER_IMPLEMENTATION), userLoggerOption),
|
||
storageInterface: storageImplementation || new DefaultStorageClass(userAuthOptions.clientId, DEFAULT_CRYPTO_IMPLEMENTATION),
|
||
networkInterface: networkImplementation || DEFAULT_NETWORK_IMPLEMENTATION,
|
||
cryptoInterface: cryptoImplementation || DEFAULT_CRYPTO_IMPLEMENTATION,
|
||
clientCredentials: clientCredentials || DEFAULT_CLIENT_CREDENTIALS,
|
||
libraryInfo: __assign(__assign({}, DEFAULT_LIBRARY_INFO), libraryInfo),
|
||
serverTelemetryManager: serverTelemetryManager || null,
|
||
persistencePlugin: persistencePlugin || null,
|
||
serializableCache: serializableCache || null
|
||
};
|
||
}
|
||
/**
|
||
* Construct authoptions from the client and platform passed values
|
||
* @param authOptions
|
||
*/
|
||
function buildAuthOptions(authOptions) {
|
||
return __assign({ clientCapabilities: [] }, authOptions);
|
||
}
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Error thrown when there is an error with the server code, for example, unavailability.
|
||
*/
|
||
var ServerError = /** @class */ (function (_super) {
|
||
__extends(ServerError, _super);
|
||
function ServerError(errorCode, errorMessage, subError) {
|
||
var _this = _super.call(this, errorCode, errorMessage, subError) || this;
|
||
_this.name = "ServerError";
|
||
Object.setPrototypeOf(_this, ServerError.prototype);
|
||
return _this;
|
||
}
|
||
return ServerError;
|
||
}(AuthError));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var ThrottlingUtils = /** @class */ (function () {
|
||
function ThrottlingUtils() {
|
||
}
|
||
/**
|
||
* Prepares a RequestThumbprint to be stored as a key.
|
||
* @param thumbprint
|
||
*/
|
||
ThrottlingUtils.generateThrottlingStorageKey = function (thumbprint) {
|
||
return ThrottlingConstants.THROTTLING_PREFIX + "." + JSON.stringify(thumbprint);
|
||
};
|
||
/**
|
||
* Performs necessary throttling checks before a network request.
|
||
* @param cacheManager
|
||
* @param thumbprint
|
||
*/
|
||
ThrottlingUtils.preProcess = function (cacheManager, thumbprint) {
|
||
var _a;
|
||
var key = ThrottlingUtils.generateThrottlingStorageKey(thumbprint);
|
||
var value = cacheManager.getThrottlingCache(key);
|
||
if (value) {
|
||
if (value.throttleTime < Date.now()) {
|
||
cacheManager.removeItem(key, CacheSchemaType.THROTTLING);
|
||
return;
|
||
}
|
||
throw new ServerError(((_a = value.errorCodes) === null || _a === void 0 ? void 0 : _a.join(" ")) || Constants.EMPTY_STRING, value.errorMessage, value.subError);
|
||
}
|
||
};
|
||
/**
|
||
* Performs necessary throttling checks after a network request.
|
||
* @param cacheManager
|
||
* @param thumbprint
|
||
* @param response
|
||
*/
|
||
ThrottlingUtils.postProcess = function (cacheManager, thumbprint, response) {
|
||
if (ThrottlingUtils.checkResponseStatus(response) || ThrottlingUtils.checkResponseForRetryAfter(response)) {
|
||
var thumbprintValue = {
|
||
throttleTime: ThrottlingUtils.calculateThrottleTime(parseInt(response.headers[HeaderNames.RETRY_AFTER])),
|
||
error: response.body.error,
|
||
errorCodes: response.body.error_codes,
|
||
errorMessage: response.body.error_description,
|
||
subError: response.body.suberror
|
||
};
|
||
cacheManager.setThrottlingCache(ThrottlingUtils.generateThrottlingStorageKey(thumbprint), thumbprintValue);
|
||
}
|
||
};
|
||
/**
|
||
* Checks a NetworkResponse object's status codes against 429 or 5xx
|
||
* @param response
|
||
*/
|
||
ThrottlingUtils.checkResponseStatus = function (response) {
|
||
return response.status === 429 || response.status >= 500 && response.status < 600;
|
||
};
|
||
/**
|
||
* Checks a NetworkResponse object's RetryAfter header
|
||
* @param response
|
||
*/
|
||
ThrottlingUtils.checkResponseForRetryAfter = function (response) {
|
||
if (response.headers) {
|
||
return response.headers.hasOwnProperty(HeaderNames.RETRY_AFTER) && (response.status < 200 || response.status >= 300);
|
||
}
|
||
return false;
|
||
};
|
||
/**
|
||
* Calculates the Unix-time value for a throttle to expire given throttleTime in seconds.
|
||
* @param throttleTime
|
||
*/
|
||
ThrottlingUtils.calculateThrottleTime = function (throttleTime) {
|
||
if (throttleTime <= 0) {
|
||
throttleTime = 0;
|
||
}
|
||
var currentSeconds = Date.now() / 1000;
|
||
return Math.floor(Math.min(currentSeconds + (throttleTime || ThrottlingConstants.DEFAULT_THROTTLE_TIME_SECONDS), currentSeconds + ThrottlingConstants.DEFAULT_MAX_THROTTLE_TIME_SECONDS) * 1000);
|
||
};
|
||
ThrottlingUtils.removeThrottle = function (cacheManager, clientId, authority, scopes, homeAccountIdentifier) {
|
||
var thumbprint = {
|
||
clientId: clientId,
|
||
authority: authority,
|
||
scopes: scopes,
|
||
homeAccountIdentifier: homeAccountIdentifier
|
||
};
|
||
var key = this.generateThrottlingStorageKey(thumbprint);
|
||
return cacheManager.removeItem(key, CacheSchemaType.THROTTLING);
|
||
};
|
||
return ThrottlingUtils;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var NetworkManager = /** @class */ (function () {
|
||
function NetworkManager(networkClient, cacheManager) {
|
||
this.networkClient = networkClient;
|
||
this.cacheManager = cacheManager;
|
||
}
|
||
/**
|
||
* Wraps sendPostRequestAsync with necessary preflight and postflight logic
|
||
* @param thumbprint
|
||
* @param tokenEndpoint
|
||
* @param options
|
||
*/
|
||
NetworkManager.prototype.sendPostRequest = function (thumbprint, tokenEndpoint, options) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var response;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
ThrottlingUtils.preProcess(this.cacheManager, thumbprint);
|
||
return [4 /*yield*/, this.networkClient.sendPostRequestAsync(tokenEndpoint, options)];
|
||
case 1:
|
||
response = _a.sent();
|
||
ThrottlingUtils.postProcess(this.cacheManager, thumbprint, response);
|
||
// Placeholder for Telemetry hook
|
||
return [2 /*return*/, response];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
return NetworkManager;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Base application class which will construct requests to send to and handle responses from the Microsoft STS using the authorization code flow.
|
||
*/
|
||
var BaseClient = /** @class */ (function () {
|
||
function BaseClient(configuration) {
|
||
// Set the configuration
|
||
this.config = buildClientConfiguration(configuration);
|
||
// Initialize the logger
|
||
this.logger = new Logger(this.config.loggerOptions, name, version);
|
||
// Initialize crypto
|
||
this.cryptoUtils = this.config.cryptoInterface;
|
||
// Initialize storage interface
|
||
this.cacheManager = this.config.storageInterface;
|
||
// Set the network interface
|
||
this.networkClient = this.config.networkInterface;
|
||
// Set the NetworkManager
|
||
this.networkManager = new NetworkManager(this.networkClient, this.cacheManager);
|
||
// Set TelemetryManager
|
||
this.serverTelemetryManager = this.config.serverTelemetryManager;
|
||
// set Authority
|
||
this.authority = this.config.authOptions.authority;
|
||
}
|
||
/**
|
||
* Creates default headers for requests to token endpoint
|
||
*/
|
||
BaseClient.prototype.createDefaultTokenRequestHeaders = function () {
|
||
var headers = this.createDefaultLibraryHeaders();
|
||
headers[HeaderNames.CONTENT_TYPE] = Constants.URL_FORM_CONTENT_TYPE;
|
||
headers[HeaderNames.X_MS_LIB_CAPABILITY] = HeaderNames.X_MS_LIB_CAPABILITY_VALUE;
|
||
if (this.serverTelemetryManager) {
|
||
headers[HeaderNames.X_CLIENT_CURR_TELEM] = this.serverTelemetryManager.generateCurrentRequestHeaderValue();
|
||
headers[HeaderNames.X_CLIENT_LAST_TELEM] = this.serverTelemetryManager.generateLastRequestHeaderValue();
|
||
}
|
||
return headers;
|
||
};
|
||
/**
|
||
* addLibraryData
|
||
*/
|
||
BaseClient.prototype.createDefaultLibraryHeaders = function () {
|
||
var headers = {};
|
||
// client info headers
|
||
headers[AADServerParamKeys.X_CLIENT_SKU] = this.config.libraryInfo.sku;
|
||
headers[AADServerParamKeys.X_CLIENT_VER] = this.config.libraryInfo.version;
|
||
headers[AADServerParamKeys.X_CLIENT_OS] = this.config.libraryInfo.os;
|
||
headers[AADServerParamKeys.X_CLIENT_CPU] = this.config.libraryInfo.cpu;
|
||
return headers;
|
||
};
|
||
/**
|
||
* Http post to token endpoint
|
||
* @param tokenEndpoint
|
||
* @param queryString
|
||
* @param headers
|
||
* @param thumbprint
|
||
*/
|
||
BaseClient.prototype.executePostToTokenEndpoint = function (tokenEndpoint, queryString, headers, thumbprint) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var response;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0: return [4 /*yield*/, this.networkManager.sendPostRequest(thumbprint, tokenEndpoint, { body: queryString, headers: headers })];
|
||
case 1:
|
||
response = _a.sent();
|
||
if (this.config.serverTelemetryManager && response.status < 500 && response.status !== 429) {
|
||
// Telemetry data successfully logged by server, clear Telemetry cache
|
||
this.config.serverTelemetryManager.clearTelemetryCache();
|
||
}
|
||
return [2 /*return*/, response];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Updates the authority object of the client. Endpoint discovery must be completed.
|
||
* @param updatedAuthority
|
||
*/
|
||
BaseClient.prototype.updateAuthority = function (updatedAuthority) {
|
||
if (!updatedAuthority.discoveryComplete()) {
|
||
throw ClientAuthError.createEndpointDiscoveryIncompleteError("Updated authority has not completed endpoint discovery.");
|
||
}
|
||
this.authority = updatedAuthority;
|
||
};
|
||
return BaseClient;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Validates server consumable params from the "request" objects
|
||
*/
|
||
var RequestValidator = /** @class */ (function () {
|
||
function RequestValidator() {
|
||
}
|
||
/**
|
||
* Utility to check if the `redirectUri` in the request is a non-null value
|
||
* @param redirectUri
|
||
*/
|
||
RequestValidator.validateRedirectUri = function (redirectUri) {
|
||
if (StringUtils.isEmpty(redirectUri)) {
|
||
throw ClientConfigurationError.createRedirectUriEmptyError();
|
||
}
|
||
};
|
||
/**
|
||
* Utility to validate prompt sent by the user in the request
|
||
* @param prompt
|
||
*/
|
||
RequestValidator.validatePrompt = function (prompt) {
|
||
if ([
|
||
PromptValue.LOGIN,
|
||
PromptValue.SELECT_ACCOUNT,
|
||
PromptValue.CONSENT,
|
||
PromptValue.NONE
|
||
].indexOf(prompt) < 0) {
|
||
throw ClientConfigurationError.createInvalidPromptError(prompt);
|
||
}
|
||
};
|
||
RequestValidator.validateClaims = function (claims) {
|
||
try {
|
||
JSON.parse(claims);
|
||
}
|
||
catch (e) {
|
||
throw ClientConfigurationError.createInvalidClaimsRequestError();
|
||
}
|
||
};
|
||
/**
|
||
* Utility to validate code_challenge and code_challenge_method
|
||
* @param codeChallenge
|
||
* @param codeChallengeMethod
|
||
*/
|
||
RequestValidator.validateCodeChallengeParams = function (codeChallenge, codeChallengeMethod) {
|
||
if (StringUtils.isEmpty(codeChallenge) || StringUtils.isEmpty(codeChallengeMethod)) {
|
||
throw ClientConfigurationError.createInvalidCodeChallengeParamsError();
|
||
}
|
||
else {
|
||
this.validateCodeChallengeMethod(codeChallengeMethod);
|
||
}
|
||
};
|
||
/**
|
||
* Utility to validate code_challenge_method
|
||
* @param codeChallengeMethod
|
||
*/
|
||
RequestValidator.validateCodeChallengeMethod = function (codeChallengeMethod) {
|
||
if ([
|
||
CodeChallengeMethodValues.PLAIN,
|
||
CodeChallengeMethodValues.S256
|
||
].indexOf(codeChallengeMethod) < 0) {
|
||
throw ClientConfigurationError.createInvalidCodeChallengeMethodError();
|
||
}
|
||
};
|
||
/**
|
||
* Removes unnecessary or duplicate query parameters from extraQueryParameters
|
||
* @param request
|
||
*/
|
||
RequestValidator.sanitizeEQParams = function (eQParams, queryParams) {
|
||
if (!eQParams) {
|
||
return {};
|
||
}
|
||
// Remove any query parameters already included in SSO params
|
||
queryParams.forEach(function (value, key) {
|
||
if (eQParams[key]) {
|
||
delete eQParams[key];
|
||
}
|
||
});
|
||
return eQParams;
|
||
};
|
||
return RequestValidator;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var RequestParameterBuilder = /** @class */ (function () {
|
||
function RequestParameterBuilder() {
|
||
this.parameters = new Map();
|
||
}
|
||
/**
|
||
* add response_type = code
|
||
*/
|
||
RequestParameterBuilder.prototype.addResponseTypeCode = function () {
|
||
this.parameters.set(AADServerParamKeys.RESPONSE_TYPE, encodeURIComponent(Constants.CODE_RESPONSE_TYPE));
|
||
};
|
||
/**
|
||
* add response_mode. defaults to query.
|
||
* @param responseMode
|
||
*/
|
||
RequestParameterBuilder.prototype.addResponseMode = function (responseMode) {
|
||
this.parameters.set(AADServerParamKeys.RESPONSE_MODE, encodeURIComponent((responseMode) ? responseMode : ResponseMode.QUERY));
|
||
};
|
||
/**
|
||
* add scopes. set addOidcScopes to false to prevent default scopes in non-user scenarios
|
||
* @param scopeSet
|
||
* @param addOidcScopes
|
||
*/
|
||
RequestParameterBuilder.prototype.addScopes = function (scopes, addOidcScopes) {
|
||
if (addOidcScopes === void 0) { addOidcScopes = true; }
|
||
var requestScopes = addOidcScopes ? __spreadArrays(scopes || [], OIDC_DEFAULT_SCOPES) : scopes || [];
|
||
var scopeSet = new ScopeSet(requestScopes);
|
||
this.parameters.set(AADServerParamKeys.SCOPE, encodeURIComponent(scopeSet.printScopes()));
|
||
};
|
||
/**
|
||
* add clientId
|
||
* @param clientId
|
||
*/
|
||
RequestParameterBuilder.prototype.addClientId = function (clientId) {
|
||
this.parameters.set(AADServerParamKeys.CLIENT_ID, encodeURIComponent(clientId));
|
||
};
|
||
/**
|
||
* add redirect_uri
|
||
* @param redirectUri
|
||
*/
|
||
RequestParameterBuilder.prototype.addRedirectUri = function (redirectUri) {
|
||
RequestValidator.validateRedirectUri(redirectUri);
|
||
this.parameters.set(AADServerParamKeys.REDIRECT_URI, encodeURIComponent(redirectUri));
|
||
};
|
||
/**
|
||
* add post logout redirectUri
|
||
* @param redirectUri
|
||
*/
|
||
RequestParameterBuilder.prototype.addPostLogoutRedirectUri = function (redirectUri) {
|
||
RequestValidator.validateRedirectUri(redirectUri);
|
||
this.parameters.set(AADServerParamKeys.POST_LOGOUT_URI, encodeURIComponent(redirectUri));
|
||
};
|
||
/**
|
||
* add id_token_hint to logout request
|
||
* @param idTokenHint
|
||
*/
|
||
RequestParameterBuilder.prototype.addIdTokenHint = function (idTokenHint) {
|
||
this.parameters.set(AADServerParamKeys.ID_TOKEN_HINT, encodeURIComponent(idTokenHint));
|
||
};
|
||
/**
|
||
* add domain_hint
|
||
* @param domainHint
|
||
*/
|
||
RequestParameterBuilder.prototype.addDomainHint = function (domainHint) {
|
||
this.parameters.set(SSOTypes.DOMAIN_HINT, encodeURIComponent(domainHint));
|
||
};
|
||
/**
|
||
* add login_hint
|
||
* @param loginHint
|
||
*/
|
||
RequestParameterBuilder.prototype.addLoginHint = function (loginHint) {
|
||
this.parameters.set(SSOTypes.LOGIN_HINT, encodeURIComponent(loginHint));
|
||
};
|
||
/**
|
||
* add sid
|
||
* @param sid
|
||
*/
|
||
RequestParameterBuilder.prototype.addSid = function (sid) {
|
||
this.parameters.set(SSOTypes.SID, encodeURIComponent(sid));
|
||
};
|
||
/**
|
||
* add claims
|
||
* @param claims
|
||
*/
|
||
RequestParameterBuilder.prototype.addClaims = function (claims, clientCapabilities) {
|
||
var mergedClaims = this.addClientCapabilitiesToClaims(claims, clientCapabilities);
|
||
RequestValidator.validateClaims(mergedClaims);
|
||
this.parameters.set(AADServerParamKeys.CLAIMS, encodeURIComponent(mergedClaims));
|
||
};
|
||
/**
|
||
* add correlationId
|
||
* @param correlationId
|
||
*/
|
||
RequestParameterBuilder.prototype.addCorrelationId = function (correlationId) {
|
||
this.parameters.set(AADServerParamKeys.CLIENT_REQUEST_ID, encodeURIComponent(correlationId));
|
||
};
|
||
/**
|
||
* add library info query params
|
||
* @param libraryInfo
|
||
*/
|
||
RequestParameterBuilder.prototype.addLibraryInfo = function (libraryInfo) {
|
||
// Telemetry Info
|
||
this.parameters.set(AADServerParamKeys.X_CLIENT_SKU, libraryInfo.sku);
|
||
this.parameters.set(AADServerParamKeys.X_CLIENT_VER, libraryInfo.version);
|
||
this.parameters.set(AADServerParamKeys.X_CLIENT_OS, libraryInfo.os);
|
||
this.parameters.set(AADServerParamKeys.X_CLIENT_CPU, libraryInfo.cpu);
|
||
};
|
||
/**
|
||
* add prompt
|
||
* @param prompt
|
||
*/
|
||
RequestParameterBuilder.prototype.addPrompt = function (prompt) {
|
||
RequestValidator.validatePrompt(prompt);
|
||
this.parameters.set("" + AADServerParamKeys.PROMPT, encodeURIComponent(prompt));
|
||
};
|
||
/**
|
||
* add state
|
||
* @param state
|
||
*/
|
||
RequestParameterBuilder.prototype.addState = function (state) {
|
||
if (!StringUtils.isEmpty(state)) {
|
||
this.parameters.set(AADServerParamKeys.STATE, encodeURIComponent(state));
|
||
}
|
||
};
|
||
/**
|
||
* add nonce
|
||
* @param nonce
|
||
*/
|
||
RequestParameterBuilder.prototype.addNonce = function (nonce) {
|
||
this.parameters.set(AADServerParamKeys.NONCE, encodeURIComponent(nonce));
|
||
};
|
||
/**
|
||
* add code_challenge and code_challenge_method
|
||
* - throw if either of them are not passed
|
||
* @param codeChallenge
|
||
* @param codeChallengeMethod
|
||
*/
|
||
RequestParameterBuilder.prototype.addCodeChallengeParams = function (codeChallenge, codeChallengeMethod) {
|
||
RequestValidator.validateCodeChallengeParams(codeChallenge, codeChallengeMethod);
|
||
if (codeChallenge && codeChallengeMethod) {
|
||
this.parameters.set(AADServerParamKeys.CODE_CHALLENGE, encodeURIComponent(codeChallenge));
|
||
this.parameters.set(AADServerParamKeys.CODE_CHALLENGE_METHOD, encodeURIComponent(codeChallengeMethod));
|
||
}
|
||
else {
|
||
throw ClientConfigurationError.createInvalidCodeChallengeParamsError();
|
||
}
|
||
};
|
||
/**
|
||
* add the `authorization_code` passed by the user to exchange for a token
|
||
* @param code
|
||
*/
|
||
RequestParameterBuilder.prototype.addAuthorizationCode = function (code) {
|
||
this.parameters.set(AADServerParamKeys.CODE, encodeURIComponent(code));
|
||
};
|
||
/**
|
||
* add the `authorization_code` passed by the user to exchange for a token
|
||
* @param code
|
||
*/
|
||
RequestParameterBuilder.prototype.addDeviceCode = function (code) {
|
||
this.parameters.set(AADServerParamKeys.DEVICE_CODE, encodeURIComponent(code));
|
||
};
|
||
/**
|
||
* add the `refreshToken` passed by the user
|
||
* @param refreshToken
|
||
*/
|
||
RequestParameterBuilder.prototype.addRefreshToken = function (refreshToken) {
|
||
this.parameters.set(AADServerParamKeys.REFRESH_TOKEN, encodeURIComponent(refreshToken));
|
||
};
|
||
/**
|
||
* add the `code_verifier` passed by the user to exchange for a token
|
||
* @param codeVerifier
|
||
*/
|
||
RequestParameterBuilder.prototype.addCodeVerifier = function (codeVerifier) {
|
||
this.parameters.set(AADServerParamKeys.CODE_VERIFIER, encodeURIComponent(codeVerifier));
|
||
};
|
||
/**
|
||
* add client_secret
|
||
* @param clientSecret
|
||
*/
|
||
RequestParameterBuilder.prototype.addClientSecret = function (clientSecret) {
|
||
this.parameters.set(AADServerParamKeys.CLIENT_SECRET, encodeURIComponent(clientSecret));
|
||
};
|
||
/**
|
||
* add clientAssertion for confidential client flows
|
||
* @param clientAssertion
|
||
*/
|
||
RequestParameterBuilder.prototype.addClientAssertion = function (clientAssertion) {
|
||
this.parameters.set(AADServerParamKeys.CLIENT_ASSERTION, encodeURIComponent(clientAssertion));
|
||
};
|
||
/**
|
||
* add clientAssertionType for confidential client flows
|
||
* @param clientAssertionType
|
||
*/
|
||
RequestParameterBuilder.prototype.addClientAssertionType = function (clientAssertionType) {
|
||
this.parameters.set(AADServerParamKeys.CLIENT_ASSERTION_TYPE, encodeURIComponent(clientAssertionType));
|
||
};
|
||
/**
|
||
* add OBO assertion for confidential client flows
|
||
* @param clientAssertion
|
||
*/
|
||
RequestParameterBuilder.prototype.addOboAssertion = function (oboAssertion) {
|
||
this.parameters.set(AADServerParamKeys.OBO_ASSERTION, encodeURIComponent(oboAssertion));
|
||
};
|
||
/**
|
||
* add grant type
|
||
* @param grantType
|
||
*/
|
||
RequestParameterBuilder.prototype.addRequestTokenUse = function (tokenUse) {
|
||
this.parameters.set(AADServerParamKeys.REQUESTED_TOKEN_USE, encodeURIComponent(tokenUse));
|
||
};
|
||
/**
|
||
* add grant type
|
||
* @param grantType
|
||
*/
|
||
RequestParameterBuilder.prototype.addGrantType = function (grantType) {
|
||
this.parameters.set(AADServerParamKeys.GRANT_TYPE, encodeURIComponent(grantType));
|
||
};
|
||
/**
|
||
* add client info
|
||
*
|
||
*/
|
||
RequestParameterBuilder.prototype.addClientInfo = function () {
|
||
this.parameters.set(ClientInfo, "1");
|
||
};
|
||
/**
|
||
* add extraQueryParams
|
||
* @param eQparams
|
||
*/
|
||
RequestParameterBuilder.prototype.addExtraQueryParameters = function (eQparams) {
|
||
var _this = this;
|
||
RequestValidator.sanitizeEQParams(eQparams, this.parameters);
|
||
Object.keys(eQparams).forEach(function (key) {
|
||
_this.parameters.set(key, eQparams[key]);
|
||
});
|
||
};
|
||
RequestParameterBuilder.prototype.addClientCapabilitiesToClaims = function (claims, clientCapabilities) {
|
||
var mergedClaims;
|
||
// Parse provided claims into JSON object or initialize empty object
|
||
if (!claims) {
|
||
mergedClaims = {};
|
||
}
|
||
else {
|
||
try {
|
||
mergedClaims = JSON.parse(claims);
|
||
}
|
||
catch (e) {
|
||
throw ClientConfigurationError.createInvalidClaimsRequestError();
|
||
}
|
||
}
|
||
if (clientCapabilities && clientCapabilities.length > 0) {
|
||
if (!mergedClaims.hasOwnProperty(ClaimsRequestKeys.ACCESS_TOKEN)) {
|
||
// Add access_token key to claims object
|
||
mergedClaims[ClaimsRequestKeys.ACCESS_TOKEN] = {};
|
||
}
|
||
// Add xms_cc claim with provided clientCapabilities to access_token key
|
||
mergedClaims[ClaimsRequestKeys.ACCESS_TOKEN][ClaimsRequestKeys.XMS_CC] = {
|
||
values: clientCapabilities
|
||
};
|
||
}
|
||
return JSON.stringify(mergedClaims);
|
||
};
|
||
/**
|
||
* adds `username` for Password Grant flow
|
||
* @param username
|
||
*/
|
||
RequestParameterBuilder.prototype.addUsername = function (username) {
|
||
this.parameters.set(PasswordGrantConstants.username, username);
|
||
};
|
||
/**
|
||
* adds `password` for Password Grant flow
|
||
* @param password
|
||
*/
|
||
RequestParameterBuilder.prototype.addPassword = function (password) {
|
||
this.parameters.set(PasswordGrantConstants.password, password);
|
||
};
|
||
/**
|
||
* add pop_jwk to query params
|
||
* @param cnfString
|
||
*/
|
||
RequestParameterBuilder.prototype.addPopToken = function (cnfString) {
|
||
if (!StringUtils.isEmpty(cnfString)) {
|
||
this.parameters.set(AADServerParamKeys.TOKEN_TYPE, AuthenticationScheme.POP);
|
||
this.parameters.set(AADServerParamKeys.REQ_CNF, encodeURIComponent(cnfString));
|
||
}
|
||
};
|
||
/**
|
||
* Utility to create a URL from the params map
|
||
*/
|
||
RequestParameterBuilder.prototype.createQueryString = function () {
|
||
var queryParameterArray = new Array();
|
||
this.parameters.forEach(function (value, key) {
|
||
queryParameterArray.push(key + "=" + value);
|
||
});
|
||
return queryParameterArray.join("&");
|
||
};
|
||
return RequestParameterBuilder;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* ID_TOKEN Cache
|
||
*
|
||
* Key:Value Schema:
|
||
*
|
||
* Key Example: uid.utid-login.microsoftonline.com-idtoken-clientId-contoso.com-
|
||
*
|
||
* Value Schema:
|
||
* {
|
||
* homeAccountId: home account identifier for the auth scheme,
|
||
* environment: entity that issued the token, represented as a full host
|
||
* credentialType: Type of credential as a string, can be one of the following: RefreshToken, AccessToken, IdToken, Password, Cookie, Certificate, Other
|
||
* clientId: client ID of the application
|
||
* secret: Actual credential as a string
|
||
* realm: Full tenant or organizational identifier that the account belongs to
|
||
* }
|
||
*/
|
||
var IdTokenEntity = /** @class */ (function (_super) {
|
||
__extends(IdTokenEntity, _super);
|
||
function IdTokenEntity() {
|
||
return _super !== null && _super.apply(this, arguments) || this;
|
||
}
|
||
/**
|
||
* Create IdTokenEntity
|
||
* @param homeAccountId
|
||
* @param authenticationResult
|
||
* @param clientId
|
||
* @param authority
|
||
*/
|
||
IdTokenEntity.createIdTokenEntity = function (homeAccountId, environment, idToken, clientId, tenantId, oboAssertion) {
|
||
var idTokenEntity = new IdTokenEntity();
|
||
idTokenEntity.credentialType = CredentialType.ID_TOKEN;
|
||
idTokenEntity.homeAccountId = homeAccountId;
|
||
idTokenEntity.environment = environment;
|
||
idTokenEntity.clientId = clientId;
|
||
idTokenEntity.secret = idToken;
|
||
idTokenEntity.realm = tenantId;
|
||
idTokenEntity.oboAssertion = oboAssertion;
|
||
return idTokenEntity;
|
||
};
|
||
/**
|
||
* Validates an entity: checks for all expected params
|
||
* @param entity
|
||
*/
|
||
IdTokenEntity.isIdTokenEntity = function (entity) {
|
||
if (!entity) {
|
||
return false;
|
||
}
|
||
return (entity.hasOwnProperty("homeAccountId") &&
|
||
entity.hasOwnProperty("environment") &&
|
||
entity.hasOwnProperty("credentialType") &&
|
||
entity.hasOwnProperty("realm") &&
|
||
entity.hasOwnProperty("clientId") &&
|
||
entity.hasOwnProperty("secret") &&
|
||
entity["credentialType"] === CredentialType.ID_TOKEN);
|
||
};
|
||
return IdTokenEntity;
|
||
}(CredentialEntity));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Utility class which exposes functions for managing date and time operations.
|
||
*/
|
||
var TimeUtils = /** @class */ (function () {
|
||
function TimeUtils() {
|
||
}
|
||
/**
|
||
* return the current time in Unix time (seconds).
|
||
*/
|
||
TimeUtils.nowSeconds = function () {
|
||
// Date.getTime() returns in milliseconds.
|
||
return Math.round(new Date().getTime() / 1000.0);
|
||
};
|
||
/**
|
||
* check if a token is expired based on given UTC time in seconds.
|
||
* @param expiresOn
|
||
*/
|
||
TimeUtils.isTokenExpired = function (expiresOn, offset) {
|
||
// check for access token expiry
|
||
var expirationSec = Number(expiresOn) || 0;
|
||
var offsetCurrentTimeSec = TimeUtils.nowSeconds() + offset;
|
||
// If current time + offset is greater than token expiration time, then token is expired.
|
||
return (offsetCurrentTimeSec > expirationSec);
|
||
};
|
||
return TimeUtils;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* ACCESS_TOKEN Credential Type
|
||
*
|
||
* Key:Value Schema:
|
||
*
|
||
* Key Example: uid.utid-login.microsoftonline.com-accesstoken-clientId-contoso.com-user.read
|
||
*
|
||
* Value Schema:
|
||
* {
|
||
* homeAccountId: home account identifier for the auth scheme,
|
||
* environment: entity that issued the token, represented as a full host
|
||
* credentialType: Type of credential as a string, can be one of the following: RefreshToken, AccessToken, IdToken, Password, Cookie, Certificate, Other
|
||
* clientId: client ID of the application
|
||
* secret: Actual credential as a string
|
||
* familyId: Family ID identifier, usually only used for refresh tokens
|
||
* realm: Full tenant or organizational identifier that the account belongs to
|
||
* target: Permissions that are included in the token, or for refresh tokens, the resource identifier.
|
||
* cachedAt: Absolute device time when entry was created in the cache.
|
||
* expiresOn: Token expiry time, calculated based on current UTC time in seconds. Represented as a string.
|
||
* extendedExpiresOn: Additional extended expiry time until when token is valid in case of server-side outage. Represented as string in UTC seconds.
|
||
* keyId: used for POP and SSH tokenTypes
|
||
* tokenType: Type of the token issued. Usually "Bearer"
|
||
* }
|
||
*/
|
||
var AccessTokenEntity = /** @class */ (function (_super) {
|
||
__extends(AccessTokenEntity, _super);
|
||
function AccessTokenEntity() {
|
||
return _super !== null && _super.apply(this, arguments) || this;
|
||
}
|
||
/**
|
||
* Create AccessTokenEntity
|
||
* @param homeAccountId
|
||
* @param environment
|
||
* @param accessToken
|
||
* @param clientId
|
||
* @param tenantId
|
||
* @param scopes
|
||
* @param expiresOn
|
||
* @param extExpiresOn
|
||
*/
|
||
AccessTokenEntity.createAccessTokenEntity = function (homeAccountId, environment, accessToken, clientId, tenantId, scopes, expiresOn, extExpiresOn, tokenType, oboAssertion) {
|
||
var atEntity = new AccessTokenEntity();
|
||
atEntity.homeAccountId = homeAccountId;
|
||
atEntity.credentialType = CredentialType.ACCESS_TOKEN;
|
||
atEntity.secret = accessToken;
|
||
var currentTime = TimeUtils.nowSeconds();
|
||
atEntity.cachedAt = currentTime.toString();
|
||
/*
|
||
* Token expiry time.
|
||
* This value should be calculated based on the current UTC time measured locally and the value expires_in Represented as a string in JSON.
|
||
*/
|
||
atEntity.expiresOn = expiresOn.toString();
|
||
atEntity.extendedExpiresOn = extExpiresOn.toString();
|
||
atEntity.environment = environment;
|
||
atEntity.clientId = clientId;
|
||
atEntity.realm = tenantId;
|
||
atEntity.target = scopes;
|
||
atEntity.oboAssertion = oboAssertion;
|
||
atEntity.tokenType = StringUtils.isEmpty(tokenType) ? AuthenticationScheme.BEARER : tokenType;
|
||
return atEntity;
|
||
};
|
||
/**
|
||
* Validates an entity: checks for all expected params
|
||
* @param entity
|
||
*/
|
||
AccessTokenEntity.isAccessTokenEntity = function (entity) {
|
||
if (!entity) {
|
||
return false;
|
||
}
|
||
return (entity.hasOwnProperty("homeAccountId") &&
|
||
entity.hasOwnProperty("environment") &&
|
||
entity.hasOwnProperty("credentialType") &&
|
||
entity.hasOwnProperty("realm") &&
|
||
entity.hasOwnProperty("clientId") &&
|
||
entity.hasOwnProperty("secret") &&
|
||
entity.hasOwnProperty("target") &&
|
||
entity["credentialType"] === CredentialType.ACCESS_TOKEN);
|
||
};
|
||
return AccessTokenEntity;
|
||
}(CredentialEntity));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* REFRESH_TOKEN Cache
|
||
*
|
||
* Key:Value Schema:
|
||
*
|
||
* Key Example: uid.utid-login.microsoftonline.com-refreshtoken-clientId--
|
||
*
|
||
* Value:
|
||
* {
|
||
* homeAccountId: home account identifier for the auth scheme,
|
||
* environment: entity that issued the token, represented as a full host
|
||
* credentialType: Type of credential as a string, can be one of the following: RefreshToken, AccessToken, IdToken, Password, Cookie, Certificate, Other
|
||
* clientId: client ID of the application
|
||
* secret: Actual credential as a string
|
||
* familyId: Family ID identifier, '1' represents Microsoft Family
|
||
* realm: Full tenant or organizational identifier that the account belongs to
|
||
* target: Permissions that are included in the token, or for refresh tokens, the resource identifier.
|
||
* }
|
||
*/
|
||
var RefreshTokenEntity = /** @class */ (function (_super) {
|
||
__extends(RefreshTokenEntity, _super);
|
||
function RefreshTokenEntity() {
|
||
return _super !== null && _super.apply(this, arguments) || this;
|
||
}
|
||
/**
|
||
* Create RefreshTokenEntity
|
||
* @param homeAccountId
|
||
* @param authenticationResult
|
||
* @param clientId
|
||
* @param authority
|
||
*/
|
||
RefreshTokenEntity.createRefreshTokenEntity = function (homeAccountId, environment, refreshToken, clientId, familyId, oboAssertion) {
|
||
var rtEntity = new RefreshTokenEntity();
|
||
rtEntity.clientId = clientId;
|
||
rtEntity.credentialType = CredentialType.REFRESH_TOKEN;
|
||
rtEntity.environment = environment;
|
||
rtEntity.homeAccountId = homeAccountId;
|
||
rtEntity.secret = refreshToken;
|
||
rtEntity.oboAssertion = oboAssertion;
|
||
if (familyId)
|
||
rtEntity.familyId = familyId;
|
||
return rtEntity;
|
||
};
|
||
/**
|
||
* Validates an entity: checks for all expected params
|
||
* @param entity
|
||
*/
|
||
RefreshTokenEntity.isRefreshTokenEntity = function (entity) {
|
||
if (!entity) {
|
||
return false;
|
||
}
|
||
return (entity.hasOwnProperty("homeAccountId") &&
|
||
entity.hasOwnProperty("environment") &&
|
||
entity.hasOwnProperty("credentialType") &&
|
||
entity.hasOwnProperty("clientId") &&
|
||
entity.hasOwnProperty("secret") &&
|
||
entity["credentialType"] === CredentialType.REFRESH_TOKEN);
|
||
};
|
||
return RefreshTokenEntity;
|
||
}(CredentialEntity));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* InteractionRequiredAuthErrorMessage class containing string constants used by error codes and messages.
|
||
*/
|
||
var InteractionRequiredAuthErrorMessage = [
|
||
"interaction_required",
|
||
"consent_required",
|
||
"login_required"
|
||
];
|
||
var InteractionRequiredAuthSubErrorMessage = [
|
||
"message_only",
|
||
"additional_action",
|
||
"basic_action",
|
||
"user_password_expired",
|
||
"consent_required"
|
||
];
|
||
/**
|
||
* Error thrown when user interaction is required at the auth server.
|
||
*/
|
||
var InteractionRequiredAuthError = /** @class */ (function (_super) {
|
||
__extends(InteractionRequiredAuthError, _super);
|
||
function InteractionRequiredAuthError(errorCode, errorMessage, subError) {
|
||
var _this = _super.call(this, errorCode, errorMessage, subError) || this;
|
||
_this.name = "InteractionRequiredAuthError";
|
||
Object.setPrototypeOf(_this, InteractionRequiredAuthError.prototype);
|
||
return _this;
|
||
}
|
||
InteractionRequiredAuthError.isInteractionRequiredError = function (errorCode, errorString, subError) {
|
||
var isInteractionRequiredErrorCode = !!errorCode && InteractionRequiredAuthErrorMessage.indexOf(errorCode) > -1;
|
||
var isInteractionRequiredSubError = !!subError && InteractionRequiredAuthSubErrorMessage.indexOf(subError) > -1;
|
||
var isInteractionRequiredErrorDesc = !!errorString && InteractionRequiredAuthErrorMessage.some(function (irErrorCode) {
|
||
return errorString.indexOf(irErrorCode) > -1;
|
||
});
|
||
return isInteractionRequiredErrorCode || isInteractionRequiredErrorDesc || isInteractionRequiredSubError;
|
||
};
|
||
return InteractionRequiredAuthError;
|
||
}(ServerError));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var CacheRecord = /** @class */ (function () {
|
||
function CacheRecord(accountEntity, idTokenEntity, accessTokenEntity, refreshTokenEntity, appMetadataEntity) {
|
||
this.account = accountEntity || null;
|
||
this.idToken = idTokenEntity || null;
|
||
this.accessToken = accessTokenEntity || null;
|
||
this.refreshToken = refreshTokenEntity || null;
|
||
this.appMetadata = appMetadataEntity || null;
|
||
}
|
||
return CacheRecord;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Class which provides helpers for OAuth 2.0 protocol specific values
|
||
*/
|
||
var ProtocolUtils = /** @class */ (function () {
|
||
function ProtocolUtils() {
|
||
}
|
||
/**
|
||
* Appends user state with random guid, or returns random guid.
|
||
* @param userState
|
||
* @param randomGuid
|
||
*/
|
||
ProtocolUtils.setRequestState = function (cryptoObj, userState, meta) {
|
||
var libraryState = ProtocolUtils.generateLibraryState(cryptoObj, meta);
|
||
return !StringUtils.isEmpty(userState) ? "" + libraryState + Constants.RESOURCE_DELIM + userState : libraryState;
|
||
};
|
||
/**
|
||
* Generates the state value used by the common library.
|
||
* @param randomGuid
|
||
* @param cryptoObj
|
||
*/
|
||
ProtocolUtils.generateLibraryState = function (cryptoObj, meta) {
|
||
if (!cryptoObj) {
|
||
throw ClientAuthError.createNoCryptoObjectError("generateLibraryState");
|
||
}
|
||
// Create a state object containing a unique id and the timestamp of the request creation
|
||
var stateObj = {
|
||
id: cryptoObj.createNewGuid()
|
||
};
|
||
if (meta) {
|
||
stateObj.meta = meta;
|
||
}
|
||
var stateString = JSON.stringify(stateObj);
|
||
return cryptoObj.base64Encode(stateString);
|
||
};
|
||
/**
|
||
* Parses the state into the RequestStateObject, which contains the LibraryState info and the state passed by the user.
|
||
* @param state
|
||
* @param cryptoObj
|
||
*/
|
||
ProtocolUtils.parseRequestState = function (cryptoObj, state) {
|
||
if (!cryptoObj) {
|
||
throw ClientAuthError.createNoCryptoObjectError("parseRequestState");
|
||
}
|
||
if (StringUtils.isEmpty(state)) {
|
||
throw ClientAuthError.createInvalidStateError(state, "Null, undefined or empty state");
|
||
}
|
||
try {
|
||
// Split the state between library state and user passed state and decode them separately
|
||
var splitState = decodeURIComponent(state).split(Constants.RESOURCE_DELIM);
|
||
var libraryState = splitState[0];
|
||
var userState = splitState.length > 1 ? splitState.slice(1).join(Constants.RESOURCE_DELIM) : "";
|
||
var libraryStateString = cryptoObj.base64Decode(libraryState);
|
||
var libraryStateObj = JSON.parse(libraryStateString);
|
||
return {
|
||
userRequestState: !StringUtils.isEmpty(userState) ? userState : "",
|
||
libraryState: libraryStateObj
|
||
};
|
||
}
|
||
catch (e) {
|
||
throw ClientAuthError.createInvalidStateError(state, e);
|
||
}
|
||
};
|
||
return ProtocolUtils;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Url object class which can perform various transformations on url strings.
|
||
*/
|
||
var UrlString = /** @class */ (function () {
|
||
function UrlString(url) {
|
||
this._urlString = url;
|
||
if (StringUtils.isEmpty(this._urlString)) {
|
||
// Throws error if url is empty
|
||
throw ClientConfigurationError.createUrlEmptyError();
|
||
}
|
||
if (StringUtils.isEmpty(this.getHash())) {
|
||
this._urlString = UrlString.canonicalizeUri(url);
|
||
}
|
||
}
|
||
Object.defineProperty(UrlString.prototype, "urlString", {
|
||
get: function () {
|
||
return this._urlString;
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
/**
|
||
* Ensure urls are lower case and end with a / character.
|
||
* @param url
|
||
*/
|
||
UrlString.canonicalizeUri = function (url) {
|
||
if (url) {
|
||
url = url.toLowerCase();
|
||
if (StringUtils.endsWith(url, "?")) {
|
||
url = url.slice(0, -1);
|
||
}
|
||
else if (StringUtils.endsWith(url, "?/")) {
|
||
url = url.slice(0, -2);
|
||
}
|
||
if (!StringUtils.endsWith(url, "/")) {
|
||
url += "/";
|
||
}
|
||
}
|
||
return url;
|
||
};
|
||
/**
|
||
* Throws if urlString passed is not a valid authority URI string.
|
||
*/
|
||
UrlString.prototype.validateAsUri = function () {
|
||
// Attempts to parse url for uri components
|
||
var components;
|
||
try {
|
||
components = this.getUrlComponents();
|
||
}
|
||
catch (e) {
|
||
throw ClientConfigurationError.createUrlParseError(e);
|
||
}
|
||
// Throw error if URI or path segments are not parseable.
|
||
if (!components.HostNameAndPort || !components.PathSegments) {
|
||
throw ClientConfigurationError.createUrlParseError("Given url string: " + this.urlString);
|
||
}
|
||
// Throw error if uri is insecure.
|
||
if (!components.Protocol || components.Protocol.toLowerCase() !== "https:") {
|
||
throw ClientConfigurationError.createInsecureAuthorityUriError(this.urlString);
|
||
}
|
||
};
|
||
/**
|
||
* Function to remove query string params from url. Returns the new url.
|
||
* @param url
|
||
* @param name
|
||
*/
|
||
UrlString.prototype.urlRemoveQueryStringParameter = function (name) {
|
||
var regex = new RegExp("(\\&" + name + "=)[^\&]+");
|
||
this._urlString = this.urlString.replace(regex, "");
|
||
// name=value&
|
||
regex = new RegExp("(" + name + "=)[^\&]+&");
|
||
this._urlString = this.urlString.replace(regex, "");
|
||
// name=value
|
||
regex = new RegExp("(" + name + "=)[^\&]+");
|
||
this._urlString = this.urlString.replace(regex, "");
|
||
return this.urlString;
|
||
};
|
||
UrlString.removeHashFromUrl = function (url) {
|
||
return UrlString.canonicalizeUri(url.split("#")[0]);
|
||
};
|
||
/**
|
||
* Given a url like https://a:b/common/d?e=f#g, and a tenantId, returns https://a:b/tenantId/d
|
||
* @param href The url
|
||
* @param tenantId The tenant id to replace
|
||
*/
|
||
UrlString.prototype.replaceTenantPath = function (tenantId) {
|
||
var urlObject = this.getUrlComponents();
|
||
var pathArray = urlObject.PathSegments;
|
||
if (tenantId && (pathArray.length !== 0 && (pathArray[0] === AADAuthorityConstants.COMMON || pathArray[0] === AADAuthorityConstants.ORGANIZATIONS))) {
|
||
pathArray[0] = tenantId;
|
||
}
|
||
return UrlString.constructAuthorityUriFromObject(urlObject);
|
||
};
|
||
/**
|
||
* Returns the anchor part(#) of the URL
|
||
*/
|
||
UrlString.prototype.getHash = function () {
|
||
return UrlString.parseHash(this.urlString);
|
||
};
|
||
/**
|
||
* Parses out the components from a url string.
|
||
* @returns An object with the various components. Please cache this value insted of calling this multiple times on the same url.
|
||
*/
|
||
UrlString.prototype.getUrlComponents = function () {
|
||
// https://gist.github.com/curtisz/11139b2cfcaef4a261e0
|
||
var regEx = RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?");
|
||
// If url string does not match regEx, we throw an error
|
||
var match = this.urlString.match(regEx);
|
||
if (!match) {
|
||
throw ClientConfigurationError.createUrlParseError("Given url string: " + this.urlString);
|
||
}
|
||
// Url component object
|
||
var urlComponents = {
|
||
Protocol: match[1],
|
||
HostNameAndPort: match[4],
|
||
AbsolutePath: match[5],
|
||
QueryString: match[7]
|
||
};
|
||
var pathSegments = urlComponents.AbsolutePath.split("/");
|
||
pathSegments = pathSegments.filter(function (val) { return val && val.length > 0; }); // remove empty elements
|
||
urlComponents.PathSegments = pathSegments;
|
||
if (!StringUtils.isEmpty(urlComponents.QueryString) && urlComponents.QueryString.endsWith("/")) {
|
||
urlComponents.QueryString = urlComponents.QueryString.substring(0, urlComponents.QueryString.length - 1);
|
||
}
|
||
return urlComponents;
|
||
};
|
||
UrlString.getDomainFromUrl = function (url) {
|
||
var regEx = RegExp("^([^:/?#]+://)?([^/?#]*)");
|
||
var match = url.match(regEx);
|
||
if (!match) {
|
||
throw ClientConfigurationError.createUrlParseError("Given url string: " + url);
|
||
}
|
||
return match[2];
|
||
};
|
||
UrlString.getAbsoluteUrl = function (relativeUrl, baseUrl) {
|
||
if (relativeUrl[0] === Constants.FORWARD_SLASH) {
|
||
var url = new UrlString(baseUrl);
|
||
var baseComponents = url.getUrlComponents();
|
||
return baseComponents.Protocol + "//" + baseComponents.HostNameAndPort + relativeUrl;
|
||
}
|
||
return relativeUrl;
|
||
};
|
||
/**
|
||
* Parses hash string from given string. Returns empty string if no hash symbol is found.
|
||
* @param hashString
|
||
*/
|
||
UrlString.parseHash = function (hashString) {
|
||
var hashIndex1 = hashString.indexOf("#");
|
||
var hashIndex2 = hashString.indexOf("#/");
|
||
if (hashIndex2 > -1) {
|
||
return hashString.substring(hashIndex2 + 2);
|
||
}
|
||
else if (hashIndex1 > -1) {
|
||
return hashString.substring(hashIndex1 + 1);
|
||
}
|
||
return "";
|
||
};
|
||
UrlString.constructAuthorityUriFromObject = function (urlObject) {
|
||
return new UrlString(urlObject.Protocol + "//" + urlObject.HostNameAndPort + "/" + urlObject.PathSegments.join("/"));
|
||
};
|
||
/**
|
||
* Returns URL hash as server auth code response object.
|
||
*/
|
||
UrlString.getDeserializedHash = function (hash) {
|
||
// Check if given hash is empty
|
||
if (StringUtils.isEmpty(hash)) {
|
||
return {};
|
||
}
|
||
// Strip the # symbol if present
|
||
var parsedHash = UrlString.parseHash(hash);
|
||
// If # symbol was not present, above will return empty string, so give original hash value
|
||
var deserializedHash = StringUtils.queryStringToObject(StringUtils.isEmpty(parsedHash) ? hash : parsedHash);
|
||
// Check if deserialization didn't work
|
||
if (!deserializedHash) {
|
||
throw ClientAuthError.createHashNotDeserializedError(JSON.stringify(deserializedHash));
|
||
}
|
||
return deserializedHash;
|
||
};
|
||
/**
|
||
* Check if the hash of the URL string contains known properties
|
||
*/
|
||
UrlString.hashContainsKnownProperties = function (hash) {
|
||
if (StringUtils.isEmpty(hash)) {
|
||
return false;
|
||
}
|
||
var parameters = UrlString.getDeserializedHash(hash);
|
||
return !!(parameters.code ||
|
||
parameters.error_description ||
|
||
parameters.error ||
|
||
parameters.state);
|
||
};
|
||
return UrlString;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var KeyLocation;
|
||
(function (KeyLocation) {
|
||
KeyLocation["SW"] = "sw";
|
||
KeyLocation["UHW"] = "uhw";
|
||
})(KeyLocation || (KeyLocation = {}));
|
||
var PopTokenGenerator = /** @class */ (function () {
|
||
function PopTokenGenerator(cryptoUtils) {
|
||
this.cryptoUtils = cryptoUtils;
|
||
}
|
||
PopTokenGenerator.prototype.generateCnf = function (resourceRequestMethod, resourceRequestUri) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var kidThumbprint, reqCnf;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0: return [4 /*yield*/, this.cryptoUtils.getPublicKeyThumbprint(resourceRequestMethod, resourceRequestUri)];
|
||
case 1:
|
||
kidThumbprint = _a.sent();
|
||
reqCnf = {
|
||
kid: kidThumbprint,
|
||
xms_ksl: KeyLocation.SW
|
||
};
|
||
return [2 /*return*/, this.cryptoUtils.base64Encode(JSON.stringify(reqCnf))];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
PopTokenGenerator.prototype.signPopToken = function (accessToken, resourceRequestMethod, resourceRequestUri) {
|
||
var _a;
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var tokenClaims, resourceUrlString, resourceUrlComponents;
|
||
return __generator(this, function (_b) {
|
||
switch (_b.label) {
|
||
case 0:
|
||
tokenClaims = AuthToken.extractTokenClaims(accessToken, this.cryptoUtils);
|
||
resourceUrlString = new UrlString(resourceRequestUri);
|
||
resourceUrlComponents = resourceUrlString.getUrlComponents();
|
||
if (!((_a = tokenClaims === null || tokenClaims === void 0 ? void 0 : tokenClaims.cnf) === null || _a === void 0 ? void 0 : _a.kid)) {
|
||
throw ClientAuthError.createTokenClaimsRequiredError();
|
||
}
|
||
return [4 /*yield*/, this.cryptoUtils.signJwt({
|
||
at: accessToken,
|
||
ts: "" + TimeUtils.nowSeconds(),
|
||
m: resourceRequestMethod.toUpperCase(),
|
||
u: resourceUrlComponents.HostNameAndPort || "",
|
||
nonce: this.cryptoUtils.createNewGuid(),
|
||
p: resourceUrlComponents.AbsolutePath,
|
||
q: [[], resourceUrlComponents.QueryString],
|
||
}, tokenClaims.cnf.kid)];
|
||
case 1: return [2 /*return*/, _b.sent()];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
return PopTokenGenerator;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* APP_METADATA Cache
|
||
*
|
||
* Key:Value Schema:
|
||
*
|
||
* Key: appmetadata-<environment>-<client_id>
|
||
*
|
||
* Value:
|
||
* {
|
||
* clientId: client ID of the application
|
||
* environment: entity that issued the token, represented as a full host
|
||
* familyId: Family ID identifier, '1' represents Microsoft Family
|
||
* }
|
||
*/
|
||
var AppMetadataEntity = /** @class */ (function () {
|
||
function AppMetadataEntity() {
|
||
}
|
||
/**
|
||
* Generate AppMetadata Cache Key as per the schema: appmetadata-<environment>-<client_id>
|
||
*/
|
||
AppMetadataEntity.prototype.generateAppMetadataKey = function () {
|
||
return AppMetadataEntity.generateAppMetadataCacheKey(this.environment, this.clientId);
|
||
};
|
||
/**
|
||
* Generate AppMetadata Cache Key
|
||
*/
|
||
AppMetadataEntity.generateAppMetadataCacheKey = function (environment, clientId) {
|
||
var appMetaDataKeyArray = [
|
||
APP_METADATA,
|
||
environment,
|
||
clientId,
|
||
];
|
||
return appMetaDataKeyArray.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
|
||
};
|
||
/**
|
||
* Creates AppMetadataEntity
|
||
* @param clientId
|
||
* @param environment
|
||
* @param familyId
|
||
*/
|
||
AppMetadataEntity.createAppMetadataEntity = function (clientId, environment, familyId) {
|
||
var appMetadata = new AppMetadataEntity();
|
||
appMetadata.clientId = clientId;
|
||
appMetadata.environment = environment;
|
||
if (familyId) {
|
||
appMetadata.familyId = familyId;
|
||
}
|
||
return appMetadata;
|
||
};
|
||
/**
|
||
* Validates an entity: checks for all expected params
|
||
* @param entity
|
||
*/
|
||
AppMetadataEntity.isAppMetadataEntity = function (key, entity) {
|
||
if (!entity) {
|
||
return false;
|
||
}
|
||
return (key.indexOf(APP_METADATA) === 0 &&
|
||
entity.hasOwnProperty("clientId") &&
|
||
entity.hasOwnProperty("environment"));
|
||
};
|
||
return AppMetadataEntity;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* This class instance helps track the memory changes facilitating
|
||
* decisions to read from and write to the persistent cache
|
||
*/ var TokenCacheContext = /** @class */ (function () {
|
||
function TokenCacheContext(tokenCache, hasChanged) {
|
||
this.cache = tokenCache;
|
||
this.hasChanged = hasChanged;
|
||
}
|
||
Object.defineProperty(TokenCacheContext.prototype, "cacheHasChanged", {
|
||
/**
|
||
* boolean which indicates the changes in cache
|
||
*/
|
||
get: function () {
|
||
return this.hasChanged;
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
Object.defineProperty(TokenCacheContext.prototype, "tokenCache", {
|
||
/**
|
||
* function to retrieve the token cache
|
||
*/
|
||
get: function () {
|
||
return this.cache;
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
return TokenCacheContext;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Class that handles response parsing.
|
||
*/
|
||
var ResponseHandler = /** @class */ (function () {
|
||
function ResponseHandler(clientId, cacheStorage, cryptoObj, logger, serializableCache, persistencePlugin) {
|
||
this.clientId = clientId;
|
||
this.cacheStorage = cacheStorage;
|
||
this.cryptoObj = cryptoObj;
|
||
this.logger = logger;
|
||
this.serializableCache = serializableCache;
|
||
this.persistencePlugin = persistencePlugin;
|
||
}
|
||
/**
|
||
* Function which validates server authorization code response.
|
||
* @param serverResponseHash
|
||
* @param cachedState
|
||
* @param cryptoObj
|
||
*/
|
||
ResponseHandler.prototype.validateServerAuthorizationCodeResponse = function (serverResponseHash, cachedState, cryptoObj) {
|
||
if (!serverResponseHash.state || !cachedState) {
|
||
throw !serverResponseHash.state ? ClientAuthError.createStateNotFoundError("Server State") : ClientAuthError.createStateNotFoundError("Cached State");
|
||
}
|
||
if (decodeURIComponent(serverResponseHash.state) !== decodeURIComponent(cachedState)) {
|
||
throw ClientAuthError.createStateMismatchError();
|
||
}
|
||
// Check for error
|
||
if (serverResponseHash.error || serverResponseHash.error_description || serverResponseHash.suberror) {
|
||
if (InteractionRequiredAuthError.isInteractionRequiredError(serverResponseHash.error, serverResponseHash.error_description, serverResponseHash.suberror)) {
|
||
throw new InteractionRequiredAuthError(serverResponseHash.error || Constants.EMPTY_STRING, serverResponseHash.error_description, serverResponseHash.suberror);
|
||
}
|
||
throw new ServerError(serverResponseHash.error || Constants.EMPTY_STRING, serverResponseHash.error_description, serverResponseHash.suberror);
|
||
}
|
||
if (serverResponseHash.client_info) {
|
||
buildClientInfo(serverResponseHash.client_info, cryptoObj);
|
||
}
|
||
};
|
||
/**
|
||
* Function which validates server authorization token response.
|
||
* @param serverResponse
|
||
*/
|
||
ResponseHandler.prototype.validateTokenResponse = function (serverResponse) {
|
||
// Check for error
|
||
if (serverResponse.error || serverResponse.error_description || serverResponse.suberror) {
|
||
if (InteractionRequiredAuthError.isInteractionRequiredError(serverResponse.error, serverResponse.error_description, serverResponse.suberror)) {
|
||
throw new InteractionRequiredAuthError(serverResponse.error, serverResponse.error_description, serverResponse.suberror);
|
||
}
|
||
var errString = serverResponse.error_codes + " - [" + serverResponse.timestamp + "]: " + serverResponse.error_description + " - Correlation ID: " + serverResponse.correlation_id + " - Trace ID: " + serverResponse.trace_id;
|
||
throw new ServerError(serverResponse.error, errString);
|
||
}
|
||
};
|
||
/**
|
||
* Returns a constructed token response based on given string. Also manages the cache updates and cleanups.
|
||
* @param serverTokenResponse
|
||
* @param authority
|
||
*/
|
||
ResponseHandler.prototype.handleServerTokenResponse = function (serverTokenResponse, authority, reqTimestamp, resourceRequestMethod, resourceRequestUri, authCodePayload, requestScopes, oboAssertion, handlingRefreshTokenResponse) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var idTokenObj, requestStateObj, cacheRecord, cacheContext, key, account;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
if (serverTokenResponse.id_token) {
|
||
idTokenObj = new AuthToken(serverTokenResponse.id_token || Constants.EMPTY_STRING, this.cryptoObj);
|
||
// token nonce check (TODO: Add a warning if no nonce is given?)
|
||
if (authCodePayload && !StringUtils.isEmpty(authCodePayload.nonce)) {
|
||
if (idTokenObj.claims.nonce !== authCodePayload.nonce) {
|
||
throw ClientAuthError.createNonceMismatchError();
|
||
}
|
||
}
|
||
}
|
||
// generate homeAccountId
|
||
this.homeAccountIdentifier = AccountEntity.generateHomeAccountId(serverTokenResponse.client_info || Constants.EMPTY_STRING, authority.authorityType, this.logger, this.cryptoObj, idTokenObj);
|
||
if (!!authCodePayload && !!authCodePayload.state) {
|
||
requestStateObj = ProtocolUtils.parseRequestState(this.cryptoObj, authCodePayload.state);
|
||
}
|
||
cacheRecord = this.generateCacheRecord(serverTokenResponse, authority, reqTimestamp, idTokenObj, requestScopes, oboAssertion, authCodePayload);
|
||
_a.label = 1;
|
||
case 1:
|
||
_a.trys.push([1, , 4, 7]);
|
||
if (!(this.persistencePlugin && this.serializableCache)) return [3 /*break*/, 3];
|
||
this.logger.verbose("Persistence enabled, calling beforeCacheAccess");
|
||
cacheContext = new TokenCacheContext(this.serializableCache, true);
|
||
return [4 /*yield*/, this.persistencePlugin.beforeCacheAccess(cacheContext)];
|
||
case 2:
|
||
_a.sent();
|
||
_a.label = 3;
|
||
case 3:
|
||
/*
|
||
* When saving a refreshed tokens to the cache, it is expected that the account that was used is present in the cache.
|
||
* If not present, we should return null, as it's the case that another application called removeAccount in between
|
||
* the calls to getAllAccounts and acquireTokenSilent. We should not overwrite that removal.
|
||
*/
|
||
if (handlingRefreshTokenResponse && cacheRecord.account) {
|
||
key = cacheRecord.account.generateAccountKey();
|
||
account = this.cacheStorage.getAccount(key);
|
||
if (!account) {
|
||
this.logger.warning("Account used to refresh tokens not in persistence, refreshed tokens will not be stored in the cache");
|
||
return [2 /*return*/, ResponseHandler.generateAuthenticationResult(this.cryptoObj, authority, cacheRecord, false, idTokenObj, requestStateObj, resourceRequestMethod, resourceRequestUri)];
|
||
}
|
||
}
|
||
this.cacheStorage.saveCacheRecord(cacheRecord);
|
||
return [3 /*break*/, 7];
|
||
case 4:
|
||
if (!(this.persistencePlugin && this.serializableCache && cacheContext)) return [3 /*break*/, 6];
|
||
this.logger.verbose("Persistence enabled, calling afterCacheAccess");
|
||
return [4 /*yield*/, this.persistencePlugin.afterCacheAccess(cacheContext)];
|
||
case 5:
|
||
_a.sent();
|
||
_a.label = 6;
|
||
case 6: return [7 /*endfinally*/];
|
||
case 7: return [2 /*return*/, ResponseHandler.generateAuthenticationResult(this.cryptoObj, authority, cacheRecord, false, idTokenObj, requestStateObj, resourceRequestMethod, resourceRequestUri)];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Generates CacheRecord
|
||
* @param serverTokenResponse
|
||
* @param idTokenObj
|
||
* @param authority
|
||
*/
|
||
ResponseHandler.prototype.generateCacheRecord = function (serverTokenResponse, authority, reqTimestamp, idTokenObj, requestScopes, oboAssertion, authCodePayload) {
|
||
var env = authority.getPreferredCache();
|
||
if (StringUtils.isEmpty(env)) {
|
||
throw ClientAuthError.createInvalidCacheEnvironmentError();
|
||
}
|
||
// IdToken: non AAD scenarios can have empty realm
|
||
var cachedIdToken;
|
||
var cachedAccount;
|
||
if (!StringUtils.isEmpty(serverTokenResponse.id_token) && !!idTokenObj) {
|
||
cachedIdToken = IdTokenEntity.createIdTokenEntity(this.homeAccountIdentifier, env, serverTokenResponse.id_token || Constants.EMPTY_STRING, this.clientId, idTokenObj.claims.tid || Constants.EMPTY_STRING, oboAssertion);
|
||
cachedAccount = this.generateAccountEntity(serverTokenResponse, idTokenObj, authority, oboAssertion, authCodePayload);
|
||
}
|
||
// AccessToken
|
||
var cachedAccessToken = null;
|
||
if (!StringUtils.isEmpty(serverTokenResponse.access_token)) {
|
||
// If scopes not returned in server response, use request scopes
|
||
var responseScopes = serverTokenResponse.scope ? ScopeSet.fromString(serverTokenResponse.scope) : new ScopeSet(requestScopes || []);
|
||
// Use timestamp calculated before request
|
||
var tokenExpirationSeconds = reqTimestamp + (serverTokenResponse.expires_in || 0);
|
||
var extendedTokenExpirationSeconds = tokenExpirationSeconds + (serverTokenResponse.ext_expires_in || 0);
|
||
// non AAD scenarios can have empty realm
|
||
cachedAccessToken = AccessTokenEntity.createAccessTokenEntity(this.homeAccountIdentifier, env, serverTokenResponse.access_token || Constants.EMPTY_STRING, this.clientId, idTokenObj ? idTokenObj.claims.tid || Constants.EMPTY_STRING : authority.tenant, responseScopes.printScopes(), tokenExpirationSeconds, extendedTokenExpirationSeconds, serverTokenResponse.token_type, oboAssertion);
|
||
}
|
||
// refreshToken
|
||
var cachedRefreshToken = null;
|
||
if (!StringUtils.isEmpty(serverTokenResponse.refresh_token)) {
|
||
cachedRefreshToken = RefreshTokenEntity.createRefreshTokenEntity(this.homeAccountIdentifier, env, serverTokenResponse.refresh_token || Constants.EMPTY_STRING, this.clientId, serverTokenResponse.foci, oboAssertion);
|
||
}
|
||
// appMetadata
|
||
var cachedAppMetadata = null;
|
||
if (!StringUtils.isEmpty(serverTokenResponse.foci)) {
|
||
cachedAppMetadata = AppMetadataEntity.createAppMetadataEntity(this.clientId, env, serverTokenResponse.foci);
|
||
}
|
||
return new CacheRecord(cachedAccount, cachedIdToken, cachedAccessToken, cachedRefreshToken, cachedAppMetadata);
|
||
};
|
||
/**
|
||
* Generate Account
|
||
* @param serverTokenResponse
|
||
* @param idToken
|
||
* @param authority
|
||
*/
|
||
ResponseHandler.prototype.generateAccountEntity = function (serverTokenResponse, idToken, authority, oboAssertion, authCodePayload) {
|
||
var authorityType = authority.authorityType;
|
||
var cloudGraphHostName = authCodePayload ? authCodePayload.cloud_graph_host_name : "";
|
||
var msGraphhost = authCodePayload ? authCodePayload.msgraph_host : "";
|
||
// ADFS does not require client_info in the response
|
||
if (authorityType === AuthorityType.Adfs) {
|
||
this.logger.verbose("Authority type is ADFS, creating ADFS account");
|
||
return AccountEntity.createGenericAccount(authority, this.homeAccountIdentifier, idToken, oboAssertion, cloudGraphHostName, msGraphhost);
|
||
}
|
||
// This fallback applies to B2C as well as they fall under an AAD account type.
|
||
if (StringUtils.isEmpty(serverTokenResponse.client_info) && authority.protocolMode === "AAD") {
|
||
throw ClientAuthError.createClientInfoEmptyError();
|
||
}
|
||
return serverTokenResponse.client_info ?
|
||
AccountEntity.createAccount(serverTokenResponse.client_info, this.homeAccountIdentifier, authority, idToken, oboAssertion, cloudGraphHostName, msGraphhost) :
|
||
AccountEntity.createGenericAccount(authority, this.homeAccountIdentifier, idToken, oboAssertion, cloudGraphHostName, msGraphhost);
|
||
};
|
||
/**
|
||
* Creates an @AuthenticationResult from @CacheRecord , @IdToken , and a boolean that states whether or not the result is from cache.
|
||
*
|
||
* Optionally takes a state string that is set as-is in the response.
|
||
*
|
||
* @param cacheRecord
|
||
* @param idTokenObj
|
||
* @param fromTokenCache
|
||
* @param stateString
|
||
*/
|
||
ResponseHandler.generateAuthenticationResult = function (cryptoObj, authority, cacheRecord, fromTokenCache, idTokenObj, requestState, resourceRequestMethod, resourceRequestUri) {
|
||
var _a, _b, _c;
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var accessToken, responseScopes, expiresOn, extExpiresOn, familyId, popTokenGenerator, uid, tid;
|
||
return __generator(this, function (_d) {
|
||
switch (_d.label) {
|
||
case 0:
|
||
accessToken = "";
|
||
responseScopes = [];
|
||
expiresOn = null;
|
||
familyId = Constants.EMPTY_STRING;
|
||
if (!cacheRecord.accessToken) return [3 /*break*/, 4];
|
||
if (!(cacheRecord.accessToken.tokenType === AuthenticationScheme.POP)) return [3 /*break*/, 2];
|
||
popTokenGenerator = new PopTokenGenerator(cryptoObj);
|
||
if (!resourceRequestMethod || !resourceRequestUri) {
|
||
throw ClientConfigurationError.createResourceRequestParametersRequiredError();
|
||
}
|
||
return [4 /*yield*/, popTokenGenerator.signPopToken(cacheRecord.accessToken.secret, resourceRequestMethod, resourceRequestUri)];
|
||
case 1:
|
||
accessToken = _d.sent();
|
||
return [3 /*break*/, 3];
|
||
case 2:
|
||
accessToken = cacheRecord.accessToken.secret;
|
||
_d.label = 3;
|
||
case 3:
|
||
responseScopes = ScopeSet.fromString(cacheRecord.accessToken.target).asArray();
|
||
expiresOn = new Date(Number(cacheRecord.accessToken.expiresOn) * 1000);
|
||
extExpiresOn = new Date(Number(cacheRecord.accessToken.extendedExpiresOn) * 1000);
|
||
_d.label = 4;
|
||
case 4:
|
||
if (cacheRecord.appMetadata) {
|
||
familyId = cacheRecord.appMetadata.familyId === THE_FAMILY_ID ? THE_FAMILY_ID : Constants.EMPTY_STRING;
|
||
}
|
||
uid = (idTokenObj === null || idTokenObj === void 0 ? void 0 : idTokenObj.claims.oid) || (idTokenObj === null || idTokenObj === void 0 ? void 0 : idTokenObj.claims.sub) || Constants.EMPTY_STRING;
|
||
tid = (idTokenObj === null || idTokenObj === void 0 ? void 0 : idTokenObj.claims.tid) || Constants.EMPTY_STRING;
|
||
return [2 /*return*/, {
|
||
authority: authority.canonicalAuthority,
|
||
uniqueId: uid,
|
||
tenantId: tid,
|
||
scopes: responseScopes,
|
||
account: cacheRecord.account ? cacheRecord.account.getAccountInfo() : null,
|
||
idToken: idTokenObj ? idTokenObj.rawToken : Constants.EMPTY_STRING,
|
||
idTokenClaims: idTokenObj ? idTokenObj.claims : {},
|
||
accessToken: accessToken,
|
||
fromCache: fromTokenCache,
|
||
expiresOn: expiresOn,
|
||
extExpiresOn: extExpiresOn,
|
||
familyId: familyId,
|
||
tokenType: ((_a = cacheRecord.accessToken) === null || _a === void 0 ? void 0 : _a.tokenType) || Constants.EMPTY_STRING,
|
||
state: requestState ? requestState.userRequestState : Constants.EMPTY_STRING,
|
||
cloudGraphHostName: ((_b = cacheRecord.account) === null || _b === void 0 ? void 0 : _b.cloudGraphHostName) || Constants.EMPTY_STRING,
|
||
msGraphHost: ((_c = cacheRecord.account) === null || _c === void 0 ? void 0 : _c.msGraphHost) || Constants.EMPTY_STRING
|
||
}];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
return ResponseHandler;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Oauth2.0 Authorization Code client
|
||
*/
|
||
var AuthorizationCodeClient = /** @class */ (function (_super) {
|
||
__extends(AuthorizationCodeClient, _super);
|
||
function AuthorizationCodeClient(configuration) {
|
||
return _super.call(this, configuration) || this;
|
||
}
|
||
/**
|
||
* Creates the URL of the authorization request letting the user input credentials and consent to the
|
||
* application. The URL target the /authorize endpoint of the authority configured in the
|
||
* application object.
|
||
*
|
||
* Once the user inputs their credentials and consents, the authority will send a response to the redirect URI
|
||
* sent in the request and should contain an authorization code, which can then be used to acquire tokens via
|
||
* acquireToken(AuthorizationCodeRequest)
|
||
* @param request
|
||
*/
|
||
AuthorizationCodeClient.prototype.getAuthCodeUrl = function (request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var queryString;
|
||
return __generator(this, function (_a) {
|
||
queryString = this.createAuthCodeUrlQueryString(request);
|
||
return [2 /*return*/, this.authority.authorizationEndpoint + "?" + queryString];
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* API to acquire a token in exchange of 'authorization_code` acquired by the user in the first leg of the
|
||
* authorization_code_grant
|
||
* @param request
|
||
*/
|
||
AuthorizationCodeClient.prototype.acquireToken = function (request, authCodePayload) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var reqTimestamp, response, responseHandler;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.logger.info("in acquireToken call");
|
||
if (!request || StringUtils.isEmpty(request.code)) {
|
||
throw ClientAuthError.createTokenRequestCannotBeMadeError();
|
||
}
|
||
reqTimestamp = TimeUtils.nowSeconds();
|
||
return [4 /*yield*/, this.executeTokenRequest(this.authority, request)];
|
||
case 1:
|
||
response = _a.sent();
|
||
responseHandler = new ResponseHandler(this.config.authOptions.clientId, this.cacheManager, this.cryptoUtils, this.logger, this.config.serializableCache, this.config.persistencePlugin);
|
||
// Validate response. This function throws a server error if an error is returned by the server.
|
||
responseHandler.validateTokenResponse(response.body);
|
||
return [4 /*yield*/, responseHandler.handleServerTokenResponse(response.body, this.authority, reqTimestamp, request.resourceRequestMethod, request.resourceRequestUri, authCodePayload)];
|
||
case 2: return [2 /*return*/, _a.sent()];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Handles the hash fragment response from public client code request. Returns a code response used by
|
||
* the client to exchange for a token in acquireToken.
|
||
* @param hashFragment
|
||
*/
|
||
AuthorizationCodeClient.prototype.handleFragmentResponse = function (hashFragment, cachedState) {
|
||
// Handle responses.
|
||
var responseHandler = new ResponseHandler(this.config.authOptions.clientId, this.cacheManager, this.cryptoUtils, this.logger, null, null);
|
||
// Deserialize hash fragment response parameters.
|
||
var hashUrlString = new UrlString(hashFragment);
|
||
// Deserialize hash fragment response parameters.
|
||
var serverParams = UrlString.getDeserializedHash(hashUrlString.getHash());
|
||
// Get code response
|
||
responseHandler.validateServerAuthorizationCodeResponse(serverParams, cachedState, this.cryptoUtils);
|
||
// throw when there is no auth code in the response
|
||
if (!serverParams.code) {
|
||
throw ClientAuthError.createNoAuthCodeInServerResponseError();
|
||
}
|
||
return __assign(__assign({}, serverParams), {
|
||
// Code param is optional in ServerAuthorizationCodeResponse but required in AuthorizationCodePaylod
|
||
code: serverParams.code });
|
||
};
|
||
/**
|
||
* Use to log out the current user, and redirect the user to the postLogoutRedirectUri.
|
||
* Default behaviour is to redirect the user to `window.location.href`.
|
||
* @param authorityUri
|
||
*/
|
||
AuthorizationCodeClient.prototype.getLogoutUri = function (logoutRequest) {
|
||
// Throw error if logoutRequest is null/undefined
|
||
if (!logoutRequest) {
|
||
throw ClientConfigurationError.createEmptyLogoutRequestError();
|
||
}
|
||
if (logoutRequest.account) {
|
||
// Clear given account.
|
||
this.cacheManager.removeAccount(AccountEntity.generateAccountCacheKey(logoutRequest.account));
|
||
}
|
||
else {
|
||
// Clear all accounts and tokens
|
||
this.cacheManager.clear();
|
||
}
|
||
var queryString = this.createLogoutUrlQueryString(logoutRequest);
|
||
// Construct logout URI.
|
||
return StringUtils.isEmpty(queryString) ? this.authority.endSessionEndpoint : this.authority.endSessionEndpoint + "?" + queryString;
|
||
};
|
||
/**
|
||
* Executes POST request to token endpoint
|
||
* @param authority
|
||
* @param request
|
||
*/
|
||
AuthorizationCodeClient.prototype.executeTokenRequest = function (authority, request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var thumbprint, requestBody, headers;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
thumbprint = {
|
||
clientId: this.config.authOptions.clientId,
|
||
authority: authority.canonicalAuthority,
|
||
scopes: request.scopes
|
||
};
|
||
return [4 /*yield*/, this.createTokenRequestBody(request)];
|
||
case 1:
|
||
requestBody = _a.sent();
|
||
headers = this.createDefaultTokenRequestHeaders();
|
||
return [2 /*return*/, this.executePostToTokenEndpoint(authority.tokenEndpoint, requestBody, headers, thumbprint)];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Generates a map for all the params to be sent to the service
|
||
* @param request
|
||
*/
|
||
AuthorizationCodeClient.prototype.createTokenRequestBody = function (request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var parameterBuilder, clientAssertion, popTokenGenerator, cnfString, correlationId;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
parameterBuilder = new RequestParameterBuilder();
|
||
parameterBuilder.addClientId(this.config.authOptions.clientId);
|
||
// validate the redirectUri (to be a non null value)
|
||
parameterBuilder.addRedirectUri(request.redirectUri);
|
||
// Add scope array, parameter builder will add default scopes and dedupe
|
||
parameterBuilder.addScopes(request.scopes);
|
||
// add code: user set, not validated
|
||
parameterBuilder.addAuthorizationCode(request.code);
|
||
// add code_verifier if passed
|
||
if (request.codeVerifier) {
|
||
parameterBuilder.addCodeVerifier(request.codeVerifier);
|
||
}
|
||
if (this.config.clientCredentials.clientSecret) {
|
||
parameterBuilder.addClientSecret(this.config.clientCredentials.clientSecret);
|
||
}
|
||
if (this.config.clientCredentials.clientAssertion) {
|
||
clientAssertion = this.config.clientCredentials.clientAssertion;
|
||
parameterBuilder.addClientAssertion(clientAssertion.assertion);
|
||
parameterBuilder.addClientAssertionType(clientAssertion.assertionType);
|
||
}
|
||
parameterBuilder.addGrantType(GrantType.AUTHORIZATION_CODE_GRANT);
|
||
parameterBuilder.addClientInfo();
|
||
if (!(request.authenticationScheme === AuthenticationScheme.POP && !!request.resourceRequestMethod && !!request.resourceRequestUri)) return [3 /*break*/, 2];
|
||
popTokenGenerator = new PopTokenGenerator(this.cryptoUtils);
|
||
return [4 /*yield*/, popTokenGenerator.generateCnf(request.resourceRequestMethod, request.resourceRequestUri)];
|
||
case 1:
|
||
cnfString = _a.sent();
|
||
parameterBuilder.addPopToken(cnfString);
|
||
_a.label = 2;
|
||
case 2:
|
||
correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();
|
||
parameterBuilder.addCorrelationId(correlationId);
|
||
if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {
|
||
parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);
|
||
}
|
||
return [2 /*return*/, parameterBuilder.createQueryString()];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* This API validates the `AuthorizationCodeUrlRequest` and creates a URL
|
||
* @param request
|
||
*/
|
||
AuthorizationCodeClient.prototype.createAuthCodeUrlQueryString = function (request) {
|
||
var parameterBuilder = new RequestParameterBuilder();
|
||
parameterBuilder.addClientId(this.config.authOptions.clientId);
|
||
var requestScopes = __spreadArrays(request.scopes || [], request.extraScopesToConsent || []);
|
||
parameterBuilder.addScopes(requestScopes);
|
||
// validate the redirectUri (to be a non null value)
|
||
parameterBuilder.addRedirectUri(request.redirectUri);
|
||
// generate the correlationId if not set by the user and add
|
||
var correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();
|
||
parameterBuilder.addCorrelationId(correlationId);
|
||
// add response_mode. If not passed in it defaults to query.
|
||
parameterBuilder.addResponseMode(request.responseMode);
|
||
// add response_type = code
|
||
parameterBuilder.addResponseTypeCode();
|
||
// add library info parameters
|
||
parameterBuilder.addLibraryInfo(this.config.libraryInfo);
|
||
// add client_info=1
|
||
parameterBuilder.addClientInfo();
|
||
if (request.codeChallenge && request.codeChallengeMethod) {
|
||
parameterBuilder.addCodeChallengeParams(request.codeChallenge, request.codeChallengeMethod);
|
||
}
|
||
if (request.prompt) {
|
||
parameterBuilder.addPrompt(request.prompt);
|
||
}
|
||
if (request.domainHint) {
|
||
parameterBuilder.addDomainHint(request.domainHint);
|
||
}
|
||
// Add sid or loginHint with preference for sid -> loginHint -> username of AccountInfo object
|
||
if (request.sid) {
|
||
parameterBuilder.addSid(request.sid);
|
||
}
|
||
else if (request.loginHint) {
|
||
parameterBuilder.addLoginHint(request.loginHint);
|
||
}
|
||
else if (request.account && request.account.username) {
|
||
parameterBuilder.addLoginHint(request.account.username);
|
||
}
|
||
if (request.nonce) {
|
||
parameterBuilder.addNonce(request.nonce);
|
||
}
|
||
if (request.state) {
|
||
parameterBuilder.addState(request.state);
|
||
}
|
||
if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {
|
||
parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);
|
||
}
|
||
if (request.extraQueryParameters) {
|
||
parameterBuilder.addExtraQueryParameters(request.extraQueryParameters);
|
||
}
|
||
return parameterBuilder.createQueryString();
|
||
};
|
||
/**
|
||
* This API validates the `EndSessionRequest` and creates a URL
|
||
* @param request
|
||
*/
|
||
AuthorizationCodeClient.prototype.createLogoutUrlQueryString = function (request) {
|
||
var parameterBuilder = new RequestParameterBuilder();
|
||
if (request.postLogoutRedirectUri) {
|
||
parameterBuilder.addPostLogoutRedirectUri(request.postLogoutRedirectUri);
|
||
}
|
||
if (request.correlationId) {
|
||
parameterBuilder.addCorrelationId(request.correlationId);
|
||
}
|
||
if (request.idTokenHint) {
|
||
parameterBuilder.addIdTokenHint(request.idTokenHint);
|
||
}
|
||
return parameterBuilder.createQueryString();
|
||
};
|
||
return AuthorizationCodeClient;
|
||
}(BaseClient));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* OAuth2.0 Device code client
|
||
*/
|
||
var DeviceCodeClient = /** @class */ (function (_super) {
|
||
__extends(DeviceCodeClient, _super);
|
||
function DeviceCodeClient(configuration) {
|
||
return _super.call(this, configuration) || this;
|
||
}
|
||
/**
|
||
* Gets device code from device code endpoint, calls back to with device code response, and
|
||
* polls token endpoint to exchange device code for tokens
|
||
* @param request
|
||
*/
|
||
DeviceCodeClient.prototype.acquireToken = function (request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var deviceCodeResponse, reqTimestamp, response, responseHandler;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0: return [4 /*yield*/, this.getDeviceCode(request)];
|
||
case 1:
|
||
deviceCodeResponse = _a.sent();
|
||
request.deviceCodeCallback(deviceCodeResponse);
|
||
reqTimestamp = TimeUtils.nowSeconds();
|
||
return [4 /*yield*/, this.acquireTokenWithDeviceCode(request, deviceCodeResponse)];
|
||
case 2:
|
||
response = _a.sent();
|
||
responseHandler = new ResponseHandler(this.config.authOptions.clientId, this.cacheManager, this.cryptoUtils, this.logger, this.config.serializableCache, this.config.persistencePlugin);
|
||
// Validate response. This function throws a server error if an error is returned by the server.
|
||
responseHandler.validateTokenResponse(response);
|
||
return [4 /*yield*/, responseHandler.handleServerTokenResponse(response, this.authority, reqTimestamp, request.resourceRequestMethod, request.resourceRequestUri)];
|
||
case 3: return [2 /*return*/, _a.sent()];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Creates device code request and executes http GET
|
||
* @param request
|
||
*/
|
||
DeviceCodeClient.prototype.getDeviceCode = function (request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var queryString, headers, thumbprint;
|
||
return __generator(this, function (_a) {
|
||
queryString = this.createQueryString(request);
|
||
headers = this.createDefaultTokenRequestHeaders();
|
||
thumbprint = {
|
||
clientId: this.config.authOptions.clientId,
|
||
authority: request.authority,
|
||
scopes: request.scopes
|
||
};
|
||
return [2 /*return*/, this.executePostRequestToDeviceCodeEndpoint(this.authority.deviceCodeEndpoint, queryString, headers, thumbprint)];
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Executes POST request to device code endpoint
|
||
* @param deviceCodeEndpoint
|
||
* @param queryString
|
||
* @param headers
|
||
*/
|
||
DeviceCodeClient.prototype.executePostRequestToDeviceCodeEndpoint = function (deviceCodeEndpoint, queryString, headers, thumbprint) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var _a, userCode, deviceCode, verificationUri, expiresIn, interval, message;
|
||
return __generator(this, function (_b) {
|
||
switch (_b.label) {
|
||
case 0: return [4 /*yield*/, this.networkManager.sendPostRequest(thumbprint, deviceCodeEndpoint, {
|
||
body: queryString,
|
||
headers: headers
|
||
})];
|
||
case 1:
|
||
_a = (_b.sent()).body, userCode = _a.user_code, deviceCode = _a.device_code, verificationUri = _a.verification_uri, expiresIn = _a.expires_in, interval = _a.interval, message = _a.message;
|
||
return [2 /*return*/, {
|
||
userCode: userCode,
|
||
deviceCode: deviceCode,
|
||
verificationUri: verificationUri,
|
||
expiresIn: expiresIn,
|
||
interval: interval,
|
||
message: message
|
||
}];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Create device code endpoint query parameters and returns string
|
||
*/
|
||
DeviceCodeClient.prototype.createQueryString = function (request) {
|
||
var parameterBuilder = new RequestParameterBuilder();
|
||
parameterBuilder.addScopes(request.scopes);
|
||
parameterBuilder.addClientId(this.config.authOptions.clientId);
|
||
if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {
|
||
parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);
|
||
}
|
||
return parameterBuilder.createQueryString();
|
||
};
|
||
/**
|
||
* Creates token request with device code response and polls token endpoint at interval set by the device code
|
||
* response
|
||
* @param request
|
||
* @param deviceCodeResponse
|
||
*/
|
||
DeviceCodeClient.prototype.acquireTokenWithDeviceCode = function (request, deviceCodeResponse) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var requestBody, headers, userSpecifiedTimeout, deviceCodeExpirationTime, pollingIntervalMilli;
|
||
var _this = this;
|
||
return __generator(this, function (_a) {
|
||
requestBody = this.createTokenRequestBody(request, deviceCodeResponse);
|
||
headers = this.createDefaultTokenRequestHeaders();
|
||
userSpecifiedTimeout = request.timeout ? TimeUtils.nowSeconds() + request.timeout : undefined;
|
||
deviceCodeExpirationTime = TimeUtils.nowSeconds() + deviceCodeResponse.expiresIn;
|
||
pollingIntervalMilli = deviceCodeResponse.interval * 1000;
|
||
/*
|
||
* Poll token endpoint while (device code is not expired AND operation has not been cancelled by
|
||
* setting CancellationToken.cancel = true). POST request is sent at interval set by pollingIntervalMilli
|
||
*/
|
||
return [2 /*return*/, new Promise(function (resolve, reject) {
|
||
var intervalId = setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
|
||
var thumbprint, response, error_1;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
_a.trys.push([0, 6, , 7]);
|
||
if (!request.cancel) return [3 /*break*/, 1];
|
||
this.logger.error("Token request cancelled by setting DeviceCodeRequest.cancel = true");
|
||
clearInterval(intervalId);
|
||
reject(ClientAuthError.createDeviceCodeCancelledError());
|
||
return [3 /*break*/, 5];
|
||
case 1:
|
||
if (!(userSpecifiedTimeout && userSpecifiedTimeout < deviceCodeExpirationTime && TimeUtils.nowSeconds() > userSpecifiedTimeout)) return [3 /*break*/, 2];
|
||
this.logger.error("User defined timeout for device code polling reached. The timeout was set for " + userSpecifiedTimeout);
|
||
clearInterval(intervalId);
|
||
reject(ClientAuthError.createUserTimeoutReachedError());
|
||
return [3 /*break*/, 5];
|
||
case 2:
|
||
if (!(TimeUtils.nowSeconds() > deviceCodeExpirationTime)) return [3 /*break*/, 3];
|
||
if (userSpecifiedTimeout) {
|
||
this.logger.verbose("User specified timeout ignored as the device code has expired before the timeout elapsed. The user specified timeout was set for " + userSpecifiedTimeout);
|
||
}
|
||
this.logger.error("Device code expired. Expiration time of device code was " + deviceCodeExpirationTime);
|
||
clearInterval(intervalId);
|
||
reject(ClientAuthError.createDeviceCodeExpiredError());
|
||
return [3 /*break*/, 5];
|
||
case 3:
|
||
thumbprint = {
|
||
clientId: this.config.authOptions.clientId,
|
||
authority: request.authority,
|
||
scopes: request.scopes
|
||
};
|
||
return [4 /*yield*/, this.executePostToTokenEndpoint(this.authority.tokenEndpoint, requestBody, headers, thumbprint)];
|
||
case 4:
|
||
response = _a.sent();
|
||
if (response.body && response.body.error === Constants.AUTHORIZATION_PENDING) {
|
||
// user authorization is pending. Sleep for polling interval and try again
|
||
this.logger.info(response.body.error_description || "no_error_description");
|
||
}
|
||
else {
|
||
clearInterval(intervalId);
|
||
resolve(response.body);
|
||
}
|
||
_a.label = 5;
|
||
case 5: return [3 /*break*/, 7];
|
||
case 6:
|
||
error_1 = _a.sent();
|
||
clearInterval(intervalId);
|
||
reject(error_1);
|
||
return [3 /*break*/, 7];
|
||
case 7: return [2 /*return*/];
|
||
}
|
||
});
|
||
}); }, pollingIntervalMilli);
|
||
})];
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Creates query parameters and converts to string.
|
||
* @param request
|
||
* @param deviceCodeResponse
|
||
*/
|
||
DeviceCodeClient.prototype.createTokenRequestBody = function (request, deviceCodeResponse) {
|
||
var requestParameters = new RequestParameterBuilder();
|
||
requestParameters.addScopes(request.scopes);
|
||
requestParameters.addClientId(this.config.authOptions.clientId);
|
||
requestParameters.addGrantType(GrantType.DEVICE_CODE_GRANT);
|
||
requestParameters.addDeviceCode(deviceCodeResponse.deviceCode);
|
||
var correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();
|
||
requestParameters.addCorrelationId(correlationId);
|
||
requestParameters.addClientInfo();
|
||
if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {
|
||
requestParameters.addClaims(request.claims, this.config.authOptions.clientCapabilities);
|
||
}
|
||
return requestParameters.createQueryString();
|
||
};
|
||
return DeviceCodeClient;
|
||
}(BaseClient));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* OAuth2.0 refresh token client
|
||
*/
|
||
var RefreshTokenClient = /** @class */ (function (_super) {
|
||
__extends(RefreshTokenClient, _super);
|
||
function RefreshTokenClient(configuration) {
|
||
return _super.call(this, configuration) || this;
|
||
}
|
||
RefreshTokenClient.prototype.acquireToken = function (request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var reqTimestamp, response, responseHandler;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
reqTimestamp = TimeUtils.nowSeconds();
|
||
return [4 /*yield*/, this.executeTokenRequest(request, this.authority)];
|
||
case 1:
|
||
response = _a.sent();
|
||
responseHandler = new ResponseHandler(this.config.authOptions.clientId, this.cacheManager, this.cryptoUtils, this.logger, this.config.serializableCache, this.config.persistencePlugin);
|
||
responseHandler.validateTokenResponse(response.body);
|
||
return [2 /*return*/, responseHandler.handleServerTokenResponse(response.body, this.authority, reqTimestamp, request.resourceRequestMethod, request.resourceRequestUri, undefined, [], undefined, true)];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Gets cached refresh token and attaches to request, then calls acquireToken API
|
||
* @param request
|
||
*/
|
||
RefreshTokenClient.prototype.acquireTokenByRefreshToken = function (request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var isFOCI, noFamilyRTInCache, clientMismatchErrorWithFamilyRT;
|
||
return __generator(this, function (_a) {
|
||
// Cannot renew token if no request object is given.
|
||
if (!request) {
|
||
throw ClientConfigurationError.createEmptyTokenRequestError();
|
||
}
|
||
// We currently do not support silent flow for account === null use cases; This will be revisited for confidential flow usecases
|
||
if (!request.account) {
|
||
throw ClientAuthError.createNoAccountInSilentRequestError();
|
||
}
|
||
isFOCI = this.cacheManager.isAppMetadataFOCI(request.account.environment, this.config.authOptions.clientId);
|
||
// if the app is part of the family, retrive a Family refresh token if present and make a refreshTokenRequest
|
||
if (isFOCI) {
|
||
try {
|
||
return [2 /*return*/, this.acquireTokenWithCachedRefreshToken(request, true)];
|
||
}
|
||
catch (e) {
|
||
noFamilyRTInCache = e instanceof ClientAuthError && e.errorCode === ClientAuthErrorMessage.noTokensFoundError.code;
|
||
clientMismatchErrorWithFamilyRT = e instanceof ServerError && e.errorCode === Errors.INVALID_GRANT_ERROR && e.subError === Errors.CLIENT_MISMATCH_ERROR;
|
||
// if family Refresh Token (FRT) cache acquisition fails or if client_mismatch error is seen with FRT, reattempt with application Refresh Token (ART)
|
||
if (noFamilyRTInCache || clientMismatchErrorWithFamilyRT) {
|
||
return [2 /*return*/, this.acquireTokenWithCachedRefreshToken(request, false)];
|
||
// throw in all other cases
|
||
}
|
||
else {
|
||
throw e;
|
||
}
|
||
}
|
||
}
|
||
// fall back to application refresh token acquisition
|
||
return [2 /*return*/, this.acquireTokenWithCachedRefreshToken(request, false)];
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* makes a network call to acquire tokens by exchanging RefreshToken available in userCache; throws if refresh token is not cached
|
||
* @param request
|
||
*/
|
||
RefreshTokenClient.prototype.acquireTokenWithCachedRefreshToken = function (request, foci) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var refreshToken, refreshTokenRequest;
|
||
return __generator(this, function (_a) {
|
||
refreshToken = this.cacheManager.readRefreshTokenFromCache(this.config.authOptions.clientId, request.account, foci);
|
||
// no refresh Token
|
||
if (!refreshToken) {
|
||
throw ClientAuthError.createNoTokensFoundError();
|
||
}
|
||
refreshTokenRequest = __assign(__assign({}, request), { refreshToken: refreshToken.secret, authenticationScheme: AuthenticationScheme.BEARER });
|
||
return [2 /*return*/, this.acquireToken(refreshTokenRequest)];
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Constructs the network message and makes a NW call to the underlying secure token service
|
||
* @param request
|
||
* @param authority
|
||
*/
|
||
RefreshTokenClient.prototype.executeTokenRequest = function (request, authority) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var requestBody, headers, thumbprint;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0: return [4 /*yield*/, this.createTokenRequestBody(request)];
|
||
case 1:
|
||
requestBody = _a.sent();
|
||
headers = this.createDefaultTokenRequestHeaders();
|
||
thumbprint = {
|
||
clientId: this.config.authOptions.clientId,
|
||
authority: authority.canonicalAuthority,
|
||
scopes: request.scopes
|
||
};
|
||
return [2 /*return*/, this.executePostToTokenEndpoint(authority.tokenEndpoint, requestBody, headers, thumbprint)];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Helper function to create the token request body
|
||
* @param request
|
||
*/
|
||
RefreshTokenClient.prototype.createTokenRequestBody = function (request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var parameterBuilder, correlationId, clientAssertion, popTokenGenerator, _a, _b;
|
||
return __generator(this, function (_c) {
|
||
switch (_c.label) {
|
||
case 0:
|
||
parameterBuilder = new RequestParameterBuilder();
|
||
parameterBuilder.addClientId(this.config.authOptions.clientId);
|
||
parameterBuilder.addScopes(request.scopes);
|
||
parameterBuilder.addGrantType(GrantType.REFRESH_TOKEN_GRANT);
|
||
parameterBuilder.addClientInfo();
|
||
correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();
|
||
parameterBuilder.addCorrelationId(correlationId);
|
||
parameterBuilder.addRefreshToken(request.refreshToken);
|
||
if (this.config.clientCredentials.clientSecret) {
|
||
parameterBuilder.addClientSecret(this.config.clientCredentials.clientSecret);
|
||
}
|
||
if (this.config.clientCredentials.clientAssertion) {
|
||
clientAssertion = this.config.clientCredentials.clientAssertion;
|
||
parameterBuilder.addClientAssertion(clientAssertion.assertion);
|
||
parameterBuilder.addClientAssertionType(clientAssertion.assertionType);
|
||
}
|
||
if (!(request.authenticationScheme === AuthenticationScheme.POP)) return [3 /*break*/, 2];
|
||
popTokenGenerator = new PopTokenGenerator(this.cryptoUtils);
|
||
if (!request.resourceRequestMethod || !request.resourceRequestUri) {
|
||
throw ClientConfigurationError.createResourceRequestParametersRequiredError();
|
||
}
|
||
_b = (_a = parameterBuilder).addPopToken;
|
||
return [4 /*yield*/, popTokenGenerator.generateCnf(request.resourceRequestMethod, request.resourceRequestUri)];
|
||
case 1:
|
||
_b.apply(_a, [_c.sent()]);
|
||
_c.label = 2;
|
||
case 2:
|
||
if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {
|
||
parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);
|
||
}
|
||
return [2 /*return*/, parameterBuilder.createQueryString()];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
return RefreshTokenClient;
|
||
}(BaseClient));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* OAuth2.0 client credential grant
|
||
*/
|
||
var ClientCredentialClient = /** @class */ (function (_super) {
|
||
__extends(ClientCredentialClient, _super);
|
||
function ClientCredentialClient(configuration) {
|
||
return _super.call(this, configuration) || this;
|
||
}
|
||
/**
|
||
* Public API to acquire a token with ClientCredential Flow for Confidential clients
|
||
* @param request
|
||
*/
|
||
ClientCredentialClient.prototype.acquireToken = function (request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var cachedAuthenticationResult;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.scopeSet = new ScopeSet(request.scopes || []);
|
||
if (!request.skipCache) return [3 /*break*/, 2];
|
||
return [4 /*yield*/, this.executeTokenRequest(request, this.authority)];
|
||
case 1: return [2 /*return*/, _a.sent()];
|
||
case 2: return [4 /*yield*/, this.getCachedAuthenticationResult()];
|
||
case 3:
|
||
cachedAuthenticationResult = _a.sent();
|
||
if (!cachedAuthenticationResult) return [3 /*break*/, 4];
|
||
return [2 /*return*/, cachedAuthenticationResult];
|
||
case 4: return [4 /*yield*/, this.executeTokenRequest(request, this.authority)];
|
||
case 5: return [2 /*return*/, _a.sent()];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* looks up cache if the tokens are cached already
|
||
*/
|
||
ClientCredentialClient.prototype.getCachedAuthenticationResult = function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var cachedAccessToken;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
cachedAccessToken = this.readAccessTokenFromCache();
|
||
if (!cachedAccessToken ||
|
||
TimeUtils.isTokenExpired(cachedAccessToken.expiresOn, this.config.systemOptions.tokenRenewalOffsetSeconds)) {
|
||
return [2 /*return*/, null];
|
||
}
|
||
return [4 /*yield*/, ResponseHandler.generateAuthenticationResult(this.cryptoUtils, this.authority, {
|
||
account: null,
|
||
idToken: null,
|
||
accessToken: cachedAccessToken,
|
||
refreshToken: null,
|
||
appMetadata: null
|
||
}, true)];
|
||
case 1: return [2 /*return*/, _a.sent()];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Reads access token from the cache
|
||
* TODO: Move this call to cacheManager instead
|
||
*/
|
||
ClientCredentialClient.prototype.readAccessTokenFromCache = function () {
|
||
var accessTokenFilter = {
|
||
homeAccountId: "",
|
||
environment: this.authority.canonicalAuthorityUrlComponents.HostNameAndPort,
|
||
credentialType: CredentialType.ACCESS_TOKEN,
|
||
clientId: this.config.authOptions.clientId,
|
||
realm: this.authority.tenant,
|
||
target: this.scopeSet.printScopesLowerCase()
|
||
};
|
||
var credentialCache = this.cacheManager.getCredentialsFilteredBy(accessTokenFilter);
|
||
var accessTokens = Object.keys(credentialCache.accessTokens).map(function (key) { return credentialCache.accessTokens[key]; });
|
||
if (accessTokens.length < 1) {
|
||
return null;
|
||
}
|
||
else if (accessTokens.length > 1) {
|
||
throw ClientAuthError.createMultipleMatchingTokensInCacheError();
|
||
}
|
||
return accessTokens[0];
|
||
};
|
||
/**
|
||
* Makes a network call to request the token from the service
|
||
* @param request
|
||
* @param authority
|
||
*/
|
||
ClientCredentialClient.prototype.executeTokenRequest = function (request, authority) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var requestBody, headers, thumbprint, reqTimestamp, response, responseHandler, tokenResponse;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
requestBody = this.createTokenRequestBody(request);
|
||
headers = this.createDefaultTokenRequestHeaders();
|
||
thumbprint = {
|
||
clientId: this.config.authOptions.clientId,
|
||
authority: request.authority,
|
||
scopes: request.scopes
|
||
};
|
||
reqTimestamp = TimeUtils.nowSeconds();
|
||
return [4 /*yield*/, this.executePostToTokenEndpoint(authority.tokenEndpoint, requestBody, headers, thumbprint)];
|
||
case 1:
|
||
response = _a.sent();
|
||
responseHandler = new ResponseHandler(this.config.authOptions.clientId, this.cacheManager, this.cryptoUtils, this.logger, this.config.serializableCache, this.config.persistencePlugin);
|
||
responseHandler.validateTokenResponse(response.body);
|
||
return [4 /*yield*/, responseHandler.handleServerTokenResponse(response.body, this.authority, reqTimestamp, request.resourceRequestMethod, request.resourceRequestUri, undefined, request.scopes)];
|
||
case 2:
|
||
tokenResponse = _a.sent();
|
||
return [2 /*return*/, tokenResponse];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* generate the request to the server in the acceptable format
|
||
* @param request
|
||
*/
|
||
ClientCredentialClient.prototype.createTokenRequestBody = function (request) {
|
||
var parameterBuilder = new RequestParameterBuilder();
|
||
parameterBuilder.addClientId(this.config.authOptions.clientId);
|
||
parameterBuilder.addScopes(request.scopes, false);
|
||
parameterBuilder.addGrantType(GrantType.CLIENT_CREDENTIALS_GRANT);
|
||
var correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();
|
||
parameterBuilder.addCorrelationId(correlationId);
|
||
if (this.config.clientCredentials.clientSecret) {
|
||
parameterBuilder.addClientSecret(this.config.clientCredentials.clientSecret);
|
||
}
|
||
if (this.config.clientCredentials.clientAssertion) {
|
||
var clientAssertion = this.config.clientCredentials.clientAssertion;
|
||
parameterBuilder.addClientAssertion(clientAssertion.assertion);
|
||
parameterBuilder.addClientAssertionType(clientAssertion.assertionType);
|
||
}
|
||
if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {
|
||
parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);
|
||
}
|
||
return parameterBuilder.createQueryString();
|
||
};
|
||
return ClientCredentialClient;
|
||
}(BaseClient));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* On-Behalf-Of client
|
||
*/
|
||
var OnBehalfOfClient = /** @class */ (function (_super) {
|
||
__extends(OnBehalfOfClient, _super);
|
||
function OnBehalfOfClient(configuration) {
|
||
return _super.call(this, configuration) || this;
|
||
}
|
||
/**
|
||
* Public API to acquire tokens with on behalf of flow
|
||
* @param request
|
||
*/
|
||
OnBehalfOfClient.prototype.acquireToken = function (request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var cachedAuthenticationResult;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.scopeSet = new ScopeSet(request.scopes || []);
|
||
if (!request.skipCache) return [3 /*break*/, 2];
|
||
return [4 /*yield*/, this.executeTokenRequest(request, this.authority)];
|
||
case 1: return [2 /*return*/, _a.sent()];
|
||
case 2: return [4 /*yield*/, this.getCachedAuthenticationResult(request)];
|
||
case 3:
|
||
cachedAuthenticationResult = _a.sent();
|
||
if (!cachedAuthenticationResult) return [3 /*break*/, 4];
|
||
return [2 /*return*/, cachedAuthenticationResult];
|
||
case 4: return [4 /*yield*/, this.executeTokenRequest(request, this.authority)];
|
||
case 5: return [2 /*return*/, _a.sent()];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* look up cache for tokens
|
||
* @param request
|
||
*/
|
||
OnBehalfOfClient.prototype.getCachedAuthenticationResult = function (request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var cachedAccessToken, cachedIdToken, idTokenObject, cachedAccount, localAccountId, accountInfo;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
cachedAccessToken = this.readAccessTokenFromCache(request);
|
||
if (!cachedAccessToken ||
|
||
TimeUtils.isTokenExpired(cachedAccessToken.expiresOn, this.config.systemOptions.tokenRenewalOffsetSeconds)) {
|
||
return [2 /*return*/, null];
|
||
}
|
||
cachedIdToken = this.readIdTokenFromCache(request);
|
||
cachedAccount = null;
|
||
if (cachedIdToken) {
|
||
idTokenObject = new AuthToken(cachedIdToken.secret, this.config.cryptoInterface);
|
||
localAccountId = idTokenObject.claims.oid ? idTokenObject.claims.oid : idTokenObject.claims.sub;
|
||
accountInfo = {
|
||
homeAccountId: cachedIdToken.homeAccountId,
|
||
environment: cachedIdToken.environment,
|
||
tenantId: cachedIdToken.realm,
|
||
username: Constants.EMPTY_STRING,
|
||
localAccountId: localAccountId || ""
|
||
};
|
||
cachedAccount = this.readAccountFromCache(accountInfo);
|
||
}
|
||
return [4 /*yield*/, ResponseHandler.generateAuthenticationResult(this.cryptoUtils, this.authority, {
|
||
account: cachedAccount,
|
||
accessToken: cachedAccessToken,
|
||
idToken: cachedIdToken,
|
||
refreshToken: null,
|
||
appMetadata: null
|
||
}, true, idTokenObject)];
|
||
case 1: return [2 /*return*/, _a.sent()];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* read access token from cache TODO: CacheManager API should be used here
|
||
* @param request
|
||
*/
|
||
OnBehalfOfClient.prototype.readAccessTokenFromCache = function (request) {
|
||
var accessTokenFilter = {
|
||
environment: this.authority.canonicalAuthorityUrlComponents.HostNameAndPort,
|
||
credentialType: CredentialType.ACCESS_TOKEN,
|
||
clientId: this.config.authOptions.clientId,
|
||
realm: this.authority.tenant,
|
||
target: this.scopeSet.printScopesLowerCase(),
|
||
oboAssertion: request.oboAssertion
|
||
};
|
||
var credentialCache = this.cacheManager.getCredentialsFilteredBy(accessTokenFilter);
|
||
var accessTokens = Object.keys(credentialCache.accessTokens).map(function (key) { return credentialCache.accessTokens[key]; });
|
||
var numAccessTokens = accessTokens.length;
|
||
if (numAccessTokens < 1) {
|
||
return null;
|
||
}
|
||
else if (numAccessTokens > 1) {
|
||
throw ClientAuthError.createMultipleMatchingTokensInCacheError();
|
||
}
|
||
return accessTokens[0];
|
||
};
|
||
/**
|
||
* read idtoken from cache TODO: CacheManager API should be used here instead
|
||
* @param request
|
||
*/
|
||
OnBehalfOfClient.prototype.readIdTokenFromCache = function (request) {
|
||
var idTokenFilter = {
|
||
environment: this.authority.canonicalAuthorityUrlComponents.HostNameAndPort,
|
||
credentialType: CredentialType.ID_TOKEN,
|
||
clientId: this.config.authOptions.clientId,
|
||
realm: this.authority.tenant,
|
||
oboAssertion: request.oboAssertion
|
||
};
|
||
var credentialCache = this.cacheManager.getCredentialsFilteredBy(idTokenFilter);
|
||
var idTokens = Object.keys(credentialCache.idTokens).map(function (key) { return credentialCache.idTokens[key]; });
|
||
// When acquiring a token on behalf of an application, there might not be an id token in the cache
|
||
if (idTokens.length < 1) {
|
||
return null;
|
||
}
|
||
return idTokens[0];
|
||
};
|
||
/**
|
||
* read account from cache, TODO: CacheManager API should be used here instead
|
||
* @param account
|
||
*/
|
||
OnBehalfOfClient.prototype.readAccountFromCache = function (account) {
|
||
return this.cacheManager.readAccountFromCache(account);
|
||
};
|
||
/**
|
||
* Make a network call to the server requesting credentials
|
||
* @param request
|
||
* @param authority
|
||
*/
|
||
OnBehalfOfClient.prototype.executeTokenRequest = function (request, authority) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var requestBody, headers, thumbprint, reqTimestamp, response, responseHandler, tokenResponse;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
requestBody = this.createTokenRequestBody(request);
|
||
headers = this.createDefaultTokenRequestHeaders();
|
||
thumbprint = {
|
||
clientId: this.config.authOptions.clientId,
|
||
authority: request.authority,
|
||
scopes: request.scopes
|
||
};
|
||
reqTimestamp = TimeUtils.nowSeconds();
|
||
return [4 /*yield*/, this.executePostToTokenEndpoint(authority.tokenEndpoint, requestBody, headers, thumbprint)];
|
||
case 1:
|
||
response = _a.sent();
|
||
responseHandler = new ResponseHandler(this.config.authOptions.clientId, this.cacheManager, this.cryptoUtils, this.logger, this.config.serializableCache, this.config.persistencePlugin);
|
||
responseHandler.validateTokenResponse(response.body);
|
||
return [4 /*yield*/, responseHandler.handleServerTokenResponse(response.body, this.authority, reqTimestamp, request.resourceRequestMethod, request.resourceRequestUri, undefined, request.scopes, request.oboAssertion)];
|
||
case 2:
|
||
tokenResponse = _a.sent();
|
||
return [2 /*return*/, tokenResponse];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* generate a server request in accepable format
|
||
* @param request
|
||
*/
|
||
OnBehalfOfClient.prototype.createTokenRequestBody = function (request) {
|
||
var parameterBuilder = new RequestParameterBuilder();
|
||
parameterBuilder.addClientId(this.config.authOptions.clientId);
|
||
parameterBuilder.addScopes(request.scopes);
|
||
parameterBuilder.addGrantType(GrantType.JWT_BEARER);
|
||
parameterBuilder.addClientInfo();
|
||
var correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();
|
||
parameterBuilder.addCorrelationId(correlationId);
|
||
parameterBuilder.addRequestTokenUse(AADServerParamKeys.ON_BEHALF_OF);
|
||
parameterBuilder.addOboAssertion(request.oboAssertion);
|
||
if (this.config.clientCredentials.clientSecret) {
|
||
parameterBuilder.addClientSecret(this.config.clientCredentials.clientSecret);
|
||
}
|
||
if (this.config.clientCredentials.clientAssertion) {
|
||
var clientAssertion = this.config.clientCredentials.clientAssertion;
|
||
parameterBuilder.addClientAssertion(clientAssertion.assertion);
|
||
parameterBuilder.addClientAssertionType(clientAssertion.assertionType);
|
||
}
|
||
return parameterBuilder.createQueryString();
|
||
};
|
||
return OnBehalfOfClient;
|
||
}(BaseClient));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var SilentFlowClient = /** @class */ (function (_super) {
|
||
__extends(SilentFlowClient, _super);
|
||
function SilentFlowClient(configuration) {
|
||
return _super.call(this, configuration) || this;
|
||
}
|
||
/**
|
||
* Retrieves a token from cache if it is still valid, or uses the cached refresh token to renew
|
||
* the given token and returns the renewed token
|
||
* @param request
|
||
*/
|
||
SilentFlowClient.prototype.acquireToken = function (request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var e_1, refreshTokenClient;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
_a.trys.push([0, 2, , 3]);
|
||
return [4 /*yield*/, this.acquireCachedToken(request)];
|
||
case 1: return [2 /*return*/, _a.sent()];
|
||
case 2:
|
||
e_1 = _a.sent();
|
||
if (e_1 instanceof ClientAuthError && e_1.errorCode === ClientAuthErrorMessage.tokenRefreshRequired.code) {
|
||
refreshTokenClient = new RefreshTokenClient(this.config);
|
||
return [2 /*return*/, refreshTokenClient.acquireTokenByRefreshToken(request)];
|
||
}
|
||
else {
|
||
throw e_1;
|
||
}
|
||
case 3: return [2 /*return*/];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Retrieves token from cache or throws an error if it must be refreshed.
|
||
* @param request
|
||
*/
|
||
SilentFlowClient.prototype.acquireCachedToken = function (request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var requestScopes, environment, cacheRecord;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
// Cannot renew token if no request object is given.
|
||
if (!request) {
|
||
throw ClientConfigurationError.createEmptyTokenRequestError();
|
||
}
|
||
// We currently do not support silent flow for account === null use cases; This will be revisited for confidential flow usecases
|
||
if (!request.account) {
|
||
throw ClientAuthError.createNoAccountInSilentRequestError();
|
||
}
|
||
requestScopes = new ScopeSet(request.scopes || []);
|
||
environment = request.authority || this.authority.getPreferredCache();
|
||
cacheRecord = this.cacheManager.readCacheRecord(request.account, this.config.authOptions.clientId, requestScopes, environment);
|
||
if (!this.isRefreshRequired(request, cacheRecord.accessToken)) return [3 /*break*/, 1];
|
||
throw ClientAuthError.createRefreshRequiredError();
|
||
case 1:
|
||
if (this.config.serverTelemetryManager) {
|
||
this.config.serverTelemetryManager.incrementCacheHits();
|
||
}
|
||
return [4 /*yield*/, this.generateResultFromCacheRecord(cacheRecord, request.resourceRequestMethod, request.resourceRequestUri)];
|
||
case 2: return [2 /*return*/, _a.sent()];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Helper function to build response object from the CacheRecord
|
||
* @param cacheRecord
|
||
*/
|
||
SilentFlowClient.prototype.generateResultFromCacheRecord = function (cacheRecord, resourceRequestMethod, resourceRequestUri) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var idTokenObj;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
if (cacheRecord.idToken) {
|
||
idTokenObj = new AuthToken(cacheRecord.idToken.secret, this.config.cryptoInterface);
|
||
}
|
||
return [4 /*yield*/, ResponseHandler.generateAuthenticationResult(this.cryptoUtils, this.authority, cacheRecord, true, idTokenObj, undefined, resourceRequestMethod, resourceRequestUri)];
|
||
case 1: return [2 /*return*/, _a.sent()];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Given a request object and an accessTokenEntity determine if the accessToken needs to be refreshed
|
||
* @param request
|
||
* @param cachedAccessToken
|
||
*/
|
||
SilentFlowClient.prototype.isRefreshRequired = function (request, cachedAccessToken) {
|
||
if (request.forceRefresh || request.claims) {
|
||
// Must refresh due to request parameters
|
||
return true;
|
||
}
|
||
else if (!cachedAccessToken || TimeUtils.isTokenExpired(cachedAccessToken.expiresOn, this.config.systemOptions.tokenRenewalOffsetSeconds)) {
|
||
// Must refresh due to expired or non-existent access_token
|
||
return true;
|
||
}
|
||
return false;
|
||
};
|
||
return SilentFlowClient;
|
||
}(BaseClient));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Oauth2.0 Password grant client
|
||
* Note: We are only supporting public clients for password grant and for purely testing purposes
|
||
*/
|
||
var UsernamePasswordClient = /** @class */ (function (_super) {
|
||
__extends(UsernamePasswordClient, _super);
|
||
function UsernamePasswordClient(configuration) {
|
||
return _super.call(this, configuration) || this;
|
||
}
|
||
/**
|
||
* API to acquire a token by passing the username and password to the service in exchage of credentials
|
||
* password_grant
|
||
* @param request
|
||
*/
|
||
UsernamePasswordClient.prototype.acquireToken = function (request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var reqTimestamp, response, responseHandler, tokenResponse;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
this.logger.info("in acquireToken call");
|
||
reqTimestamp = TimeUtils.nowSeconds();
|
||
return [4 /*yield*/, this.executeTokenRequest(this.authority, request)];
|
||
case 1:
|
||
response = _a.sent();
|
||
responseHandler = new ResponseHandler(this.config.authOptions.clientId, this.cacheManager, this.cryptoUtils, this.logger, this.config.serializableCache, this.config.persistencePlugin);
|
||
// Validate response. This function throws a server error if an error is returned by the server.
|
||
responseHandler.validateTokenResponse(response.body);
|
||
tokenResponse = responseHandler.handleServerTokenResponse(response.body, this.authority, reqTimestamp);
|
||
return [2 /*return*/, tokenResponse];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Executes POST request to token endpoint
|
||
* @param authority
|
||
* @param request
|
||
*/
|
||
UsernamePasswordClient.prototype.executeTokenRequest = function (authority, request) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var thumbprint, requestBody, headers;
|
||
return __generator(this, function (_a) {
|
||
thumbprint = {
|
||
clientId: this.config.authOptions.clientId,
|
||
authority: authority.canonicalAuthority,
|
||
scopes: request.scopes
|
||
};
|
||
requestBody = this.createTokenRequestBody(request);
|
||
headers = this.createDefaultTokenRequestHeaders();
|
||
return [2 /*return*/, this.executePostToTokenEndpoint(authority.tokenEndpoint, requestBody, headers, thumbprint)];
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Generates a map for all the params to be sent to the service
|
||
* @param request
|
||
*/
|
||
UsernamePasswordClient.prototype.createTokenRequestBody = function (request) {
|
||
var parameterBuilder = new RequestParameterBuilder();
|
||
parameterBuilder.addClientId(this.config.authOptions.clientId);
|
||
parameterBuilder.addUsername(request.username);
|
||
parameterBuilder.addPassword(request.password);
|
||
parameterBuilder.addScopes(request.scopes);
|
||
parameterBuilder.addGrantType(GrantType.RESOURCE_OWNER_PASSWORD_GRANT);
|
||
parameterBuilder.addClientInfo();
|
||
var correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();
|
||
parameterBuilder.addCorrelationId(correlationId);
|
||
if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {
|
||
parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);
|
||
}
|
||
return parameterBuilder.createQueryString();
|
||
};
|
||
return UsernamePasswordClient;
|
||
}(BaseClient));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
function isOpenIdConfigResponse(response) {
|
||
return (response.hasOwnProperty("authorization_endpoint") &&
|
||
response.hasOwnProperty("token_endpoint") &&
|
||
response.hasOwnProperty("end_session_endpoint") &&
|
||
response.hasOwnProperty("issuer"));
|
||
}
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* Protocol modes supported by MSAL.
|
||
*/
|
||
var ProtocolMode;
|
||
(function (ProtocolMode) {
|
||
ProtocolMode["AAD"] = "AAD";
|
||
ProtocolMode["OIDC"] = "OIDC";
|
||
})(ProtocolMode || (ProtocolMode = {}));
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var AuthorityMetadataEntity = /** @class */ (function () {
|
||
function AuthorityMetadataEntity() {
|
||
this.expiresAt = TimeUtils.nowSeconds() + AUTHORITY_METADATA_CONSTANTS.REFRESH_TIME_SECONDS;
|
||
}
|
||
/**
|
||
* Update the entity with new aliases, preferred_cache and preferred_network values
|
||
* @param metadata
|
||
* @param fromNetwork
|
||
*/
|
||
AuthorityMetadataEntity.prototype.updateCloudDiscoveryMetadata = function (metadata, fromNetwork) {
|
||
this.aliases = metadata.aliases;
|
||
this.preferred_cache = metadata.preferred_cache;
|
||
this.preferred_network = metadata.preferred_network;
|
||
this.aliasesFromNetwork = fromNetwork;
|
||
};
|
||
/**
|
||
* Update the entity with new endpoints
|
||
* @param metadata
|
||
* @param fromNetwork
|
||
*/
|
||
AuthorityMetadataEntity.prototype.updateEndpointMetadata = function (metadata, fromNetwork) {
|
||
this.authorization_endpoint = metadata.authorization_endpoint;
|
||
this.token_endpoint = metadata.token_endpoint;
|
||
this.end_session_endpoint = metadata.end_session_endpoint;
|
||
this.issuer = metadata.issuer;
|
||
this.endpointsFromNetwork = fromNetwork;
|
||
};
|
||
/**
|
||
* Save the authority that was used to create this cache entry
|
||
* @param authority
|
||
*/
|
||
AuthorityMetadataEntity.prototype.updateCanonicalAuthority = function (authority) {
|
||
this.canonical_authority = authority;
|
||
};
|
||
/**
|
||
* Reset the exiresAt value
|
||
*/
|
||
AuthorityMetadataEntity.prototype.resetExpiresAt = function () {
|
||
this.expiresAt = TimeUtils.nowSeconds() + AUTHORITY_METADATA_CONSTANTS.REFRESH_TIME_SECONDS;
|
||
};
|
||
/**
|
||
* Returns whether or not the data needs to be refreshed
|
||
*/
|
||
AuthorityMetadataEntity.prototype.isExpired = function () {
|
||
return this.expiresAt <= TimeUtils.nowSeconds();
|
||
};
|
||
/**
|
||
* Validates an entity: checks for all expected params
|
||
* @param entity
|
||
*/
|
||
AuthorityMetadataEntity.isAuthorityMetadataEntity = function (key, entity) {
|
||
if (!entity) {
|
||
return false;
|
||
}
|
||
return (key.indexOf(AUTHORITY_METADATA_CONSTANTS.CACHE_KEY) === 0 &&
|
||
entity.hasOwnProperty("aliases") &&
|
||
entity.hasOwnProperty("preferred_cache") &&
|
||
entity.hasOwnProperty("preferred_network") &&
|
||
entity.hasOwnProperty("canonical_authority") &&
|
||
entity.hasOwnProperty("authorization_endpoint") &&
|
||
entity.hasOwnProperty("token_endpoint") &&
|
||
entity.hasOwnProperty("end_session_endpoint") &&
|
||
entity.hasOwnProperty("issuer") &&
|
||
entity.hasOwnProperty("aliasesFromNetwork") &&
|
||
entity.hasOwnProperty("endpointsFromNetwork") &&
|
||
entity.hasOwnProperty("expiresAt"));
|
||
};
|
||
return AuthorityMetadataEntity;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
function isCloudInstanceDiscoveryResponse(response) {
|
||
return (response.hasOwnProperty("tenant_discovery_endpoint") &&
|
||
response.hasOwnProperty("metadata"));
|
||
}
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
/**
|
||
* The authority class validates the authority URIs used by the user, and retrieves the OpenID Configuration Data from the
|
||
* endpoint. It will store the pertinent config data in this object for use during token calls.
|
||
*/
|
||
var Authority = /** @class */ (function () {
|
||
function Authority(authority, networkInterface, cacheManager, authorityOptions) {
|
||
this.canonicalAuthority = authority;
|
||
this._canonicalAuthority.validateAsUri();
|
||
this.networkInterface = networkInterface;
|
||
this.cacheManager = cacheManager;
|
||
this.authorityOptions = authorityOptions;
|
||
}
|
||
Object.defineProperty(Authority.prototype, "authorityType", {
|
||
// See above for AuthorityType
|
||
get: function () {
|
||
var pathSegments = this.canonicalAuthorityUrlComponents.PathSegments;
|
||
if (pathSegments.length && pathSegments[0].toLowerCase() === Constants.ADFS) {
|
||
return AuthorityType.Adfs;
|
||
}
|
||
return AuthorityType.Default;
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
Object.defineProperty(Authority.prototype, "protocolMode", {
|
||
/**
|
||
* ProtocolMode enum representing the way endpoints are constructed.
|
||
*/
|
||
get: function () {
|
||
return this.authorityOptions.protocolMode;
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
Object.defineProperty(Authority.prototype, "options", {
|
||
/**
|
||
* Returns authorityOptions which can be used to reinstantiate a new authority instance
|
||
*/
|
||
get: function () {
|
||
return this.authorityOptions;
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
Object.defineProperty(Authority.prototype, "canonicalAuthority", {
|
||
/**
|
||
* A URL that is the authority set by the developer
|
||
*/
|
||
get: function () {
|
||
return this._canonicalAuthority.urlString;
|
||
},
|
||
/**
|
||
* Sets canonical authority.
|
||
*/
|
||
set: function (url) {
|
||
this._canonicalAuthority = new UrlString(url);
|
||
this._canonicalAuthority.validateAsUri();
|
||
this._canonicalAuthorityUrlComponents = null;
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
Object.defineProperty(Authority.prototype, "canonicalAuthorityUrlComponents", {
|
||
/**
|
||
* Get authority components.
|
||
*/
|
||
get: function () {
|
||
if (!this._canonicalAuthorityUrlComponents) {
|
||
this._canonicalAuthorityUrlComponents = this._canonicalAuthority.getUrlComponents();
|
||
}
|
||
return this._canonicalAuthorityUrlComponents;
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
Object.defineProperty(Authority.prototype, "hostnameAndPort", {
|
||
/**
|
||
* Get hostname and port i.e. login.microsoftonline.com
|
||
*/
|
||
get: function () {
|
||
return this.canonicalAuthorityUrlComponents.HostNameAndPort.toLowerCase();
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
Object.defineProperty(Authority.prototype, "tenant", {
|
||
/**
|
||
* Get tenant for authority.
|
||
*/
|
||
get: function () {
|
||
return this.canonicalAuthorityUrlComponents.PathSegments[0];
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
Object.defineProperty(Authority.prototype, "authorizationEndpoint", {
|
||
/**
|
||
* OAuth /authorize endpoint for requests
|
||
*/
|
||
get: function () {
|
||
if (this.discoveryComplete()) {
|
||
var endpoint = this.replacePath(this.metadata.authorization_endpoint);
|
||
return this.replaceTenant(endpoint);
|
||
}
|
||
else {
|
||
throw ClientAuthError.createEndpointDiscoveryIncompleteError("Discovery incomplete.");
|
||
}
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
Object.defineProperty(Authority.prototype, "tokenEndpoint", {
|
||
/**
|
||
* OAuth /token endpoint for requests
|
||
*/
|
||
get: function () {
|
||
if (this.discoveryComplete()) {
|
||
var endpoint = this.replacePath(this.metadata.token_endpoint);
|
||
return this.replaceTenant(endpoint);
|
||
}
|
||
else {
|
||
throw ClientAuthError.createEndpointDiscoveryIncompleteError("Discovery incomplete.");
|
||
}
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
Object.defineProperty(Authority.prototype, "deviceCodeEndpoint", {
|
||
get: function () {
|
||
if (this.discoveryComplete()) {
|
||
var endpoint = this.replacePath(this.metadata.token_endpoint.replace("/token", "/devicecode"));
|
||
return this.replaceTenant(endpoint);
|
||
}
|
||
else {
|
||
throw ClientAuthError.createEndpointDiscoveryIncompleteError("Discovery incomplete.");
|
||
}
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
Object.defineProperty(Authority.prototype, "endSessionEndpoint", {
|
||
/**
|
||
* OAuth logout endpoint for requests
|
||
*/
|
||
get: function () {
|
||
if (this.discoveryComplete()) {
|
||
var endpoint = this.replacePath(this.metadata.end_session_endpoint);
|
||
return this.replaceTenant(endpoint);
|
||
}
|
||
else {
|
||
throw ClientAuthError.createEndpointDiscoveryIncompleteError("Discovery incomplete.");
|
||
}
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
Object.defineProperty(Authority.prototype, "selfSignedJwtAudience", {
|
||
/**
|
||
* OAuth issuer for requests
|
||
*/
|
||
get: function () {
|
||
if (this.discoveryComplete()) {
|
||
var endpoint = this.replacePath(this.metadata.issuer);
|
||
return this.replaceTenant(endpoint);
|
||
}
|
||
else {
|
||
throw ClientAuthError.createEndpointDiscoveryIncompleteError("Discovery incomplete.");
|
||
}
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
/**
|
||
* Replaces tenant in url path with current tenant. Defaults to common.
|
||
* @param urlString
|
||
*/
|
||
Authority.prototype.replaceTenant = function (urlString) {
|
||
return urlString.replace(/{tenant}|{tenantid}/g, this.tenant);
|
||
};
|
||
/**
|
||
* Replaces path such as tenant or policy with the current tenant or policy.
|
||
* @param urlString
|
||
*/
|
||
Authority.prototype.replacePath = function (urlString) {
|
||
var endpoint = urlString;
|
||
var cachedAuthorityUrl = new UrlString(this.metadata.canonical_authority);
|
||
var cachedAuthorityParts = cachedAuthorityUrl.getUrlComponents().PathSegments;
|
||
var currentAuthorityParts = this.canonicalAuthorityUrlComponents.PathSegments;
|
||
currentAuthorityParts.forEach(function (currentPart, index) {
|
||
var cachedPart = cachedAuthorityParts[index];
|
||
if (currentPart !== cachedPart) {
|
||
endpoint = endpoint.replace("/" + cachedPart + "/", "/" + currentPart + "/");
|
||
}
|
||
});
|
||
return endpoint;
|
||
};
|
||
Object.defineProperty(Authority.prototype, "defaultOpenIdConfigurationEndpoint", {
|
||
/**
|
||
* The default open id configuration endpoint for any canonical authority.
|
||
*/
|
||
get: function () {
|
||
if (this.authorityType === AuthorityType.Adfs || this.protocolMode === ProtocolMode.OIDC) {
|
||
return this.canonicalAuthority + ".well-known/openid-configuration";
|
||
}
|
||
return this.canonicalAuthority + "v2.0/.well-known/openid-configuration";
|
||
},
|
||
enumerable: true,
|
||
configurable: true
|
||
});
|
||
/**
|
||
* Boolean that returns whethr or not tenant discovery has been completed.
|
||
*/
|
||
Authority.prototype.discoveryComplete = function () {
|
||
return !!this.metadata;
|
||
};
|
||
/**
|
||
* Perform endpoint discovery to discover aliases, preferred_cache, preferred_network
|
||
* and the /authorize, /token and logout endpoints.
|
||
*/
|
||
Authority.prototype.resolveEndpointsAsync = function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var metadataEntity, cloudDiscoverySource, endpointSource, cacheKey;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
metadataEntity = this.cacheManager.getAuthorityMetadataByAlias(this.hostnameAndPort);
|
||
if (!metadataEntity) {
|
||
metadataEntity = new AuthorityMetadataEntity();
|
||
metadataEntity.updateCanonicalAuthority(this.canonicalAuthority);
|
||
}
|
||
return [4 /*yield*/, this.updateCloudDiscoveryMetadata(metadataEntity)];
|
||
case 1:
|
||
cloudDiscoverySource = _a.sent();
|
||
this.canonicalAuthority = this.canonicalAuthority.replace(this.hostnameAndPort, metadataEntity.preferred_network);
|
||
return [4 /*yield*/, this.updateEndpointMetadata(metadataEntity)];
|
||
case 2:
|
||
endpointSource = _a.sent();
|
||
if (cloudDiscoverySource !== AuthorityMetadataSource.CACHE && endpointSource !== AuthorityMetadataSource.CACHE) {
|
||
// Reset the expiration time unless both values came from a successful cache lookup
|
||
metadataEntity.resetExpiresAt();
|
||
metadataEntity.updateCanonicalAuthority(this.canonicalAuthority);
|
||
}
|
||
cacheKey = this.cacheManager.generateAuthorityMetadataCacheKey(metadataEntity.preferred_cache);
|
||
this.cacheManager.setAuthorityMetadata(cacheKey, metadataEntity);
|
||
this.metadata = metadataEntity;
|
||
return [2 /*return*/];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Update AuthorityMetadataEntity with new endpoints and return where the information came from
|
||
* @param metadataEntity
|
||
*/
|
||
Authority.prototype.updateEndpointMetadata = function (metadataEntity) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var metadata;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
metadata = this.getEndpointMetadataFromConfig();
|
||
if (metadata) {
|
||
metadataEntity.updateEndpointMetadata(metadata, false);
|
||
return [2 /*return*/, AuthorityMetadataSource.CONFIG];
|
||
}
|
||
if (this.isAuthoritySameType(metadataEntity) && metadataEntity.endpointsFromNetwork && !metadataEntity.isExpired()) {
|
||
// No need to update
|
||
return [2 /*return*/, AuthorityMetadataSource.CACHE];
|
||
}
|
||
return [4 /*yield*/, this.getEndpointMetadataFromNetwork()];
|
||
case 1:
|
||
metadata = _a.sent();
|
||
if (metadata) {
|
||
metadataEntity.updateEndpointMetadata(metadata, true);
|
||
return [2 /*return*/, AuthorityMetadataSource.NETWORK];
|
||
}
|
||
else {
|
||
throw ClientAuthError.createUnableToGetOpenidConfigError(this.defaultOpenIdConfigurationEndpoint);
|
||
}
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Compares the number of url components after the domain to determine if the cached authority metadata can be used for the requested authority
|
||
* Protects against same domain different authority such as login.microsoftonline.com/tenant and login.microsoftonline.com/tfp/tenant/policy
|
||
* @param metadataEntity
|
||
*/
|
||
Authority.prototype.isAuthoritySameType = function (metadataEntity) {
|
||
var cachedAuthorityUrl = new UrlString(metadataEntity.canonical_authority);
|
||
var cachedParts = cachedAuthorityUrl.getUrlComponents().PathSegments;
|
||
return cachedParts.length === this.canonicalAuthorityUrlComponents.PathSegments.length;
|
||
};
|
||
/**
|
||
* Parse authorityMetadata config option
|
||
*/
|
||
Authority.prototype.getEndpointMetadataFromConfig = function () {
|
||
if (this.authorityOptions.authorityMetadata) {
|
||
try {
|
||
return JSON.parse(this.authorityOptions.authorityMetadata);
|
||
}
|
||
catch (e) {
|
||
throw ClientConfigurationError.createInvalidAuthorityMetadataError();
|
||
}
|
||
}
|
||
return null;
|
||
};
|
||
/**
|
||
* Gets OAuth endpoints from the given OpenID configuration endpoint.
|
||
*/
|
||
Authority.prototype.getEndpointMetadataFromNetwork = function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var response, e_1;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
_a.trys.push([0, 2, , 3]);
|
||
return [4 /*yield*/, this.networkInterface.sendGetRequestAsync(this.defaultOpenIdConfigurationEndpoint)];
|
||
case 1:
|
||
response = _a.sent();
|
||
return [2 /*return*/, isOpenIdConfigResponse(response.body) ? response.body : null];
|
||
case 2:
|
||
e_1 = _a.sent();
|
||
return [2 /*return*/, null];
|
||
case 3: return [2 /*return*/];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Updates the AuthorityMetadataEntity with new aliases, preferred_network and preferred_cache and returns where the information was retrived from
|
||
* @param cachedMetadata
|
||
* @param newMetadata
|
||
*/
|
||
Authority.prototype.updateCloudDiscoveryMetadata = function (metadataEntity) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var metadata;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
metadata = this.getCloudDiscoveryMetadataFromConfig();
|
||
if (metadata) {
|
||
metadataEntity.updateCloudDiscoveryMetadata(metadata, false);
|
||
return [2 /*return*/, AuthorityMetadataSource.CONFIG];
|
||
}
|
||
// If The cached metadata came from config but that config was not passed to this instance, we must go to the network
|
||
if (this.isAuthoritySameType(metadataEntity) && metadataEntity.aliasesFromNetwork && !metadataEntity.isExpired()) {
|
||
// No need to update
|
||
return [2 /*return*/, AuthorityMetadataSource.CACHE];
|
||
}
|
||
return [4 /*yield*/, this.getCloudDiscoveryMetadataFromNetwork()];
|
||
case 1:
|
||
metadata = _a.sent();
|
||
if (metadata) {
|
||
metadataEntity.updateCloudDiscoveryMetadata(metadata, true);
|
||
return [2 /*return*/, AuthorityMetadataSource.NETWORK];
|
||
}
|
||
else {
|
||
// Metadata could not be obtained from config, cache or network
|
||
throw ClientConfigurationError.createUntrustedAuthorityError();
|
||
}
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Parse cloudDiscoveryMetadata config or check knownAuthorities
|
||
*/
|
||
Authority.prototype.getCloudDiscoveryMetadataFromConfig = function () {
|
||
// Check if network response was provided in config
|
||
if (this.authorityOptions.cloudDiscoveryMetadata) {
|
||
try {
|
||
var parsedResponse = JSON.parse(this.authorityOptions.cloudDiscoveryMetadata);
|
||
var metadata = Authority.getCloudDiscoveryMetadataFromNetworkResponse(parsedResponse.metadata, this.hostnameAndPort);
|
||
if (metadata) {
|
||
return metadata;
|
||
}
|
||
}
|
||
catch (e) {
|
||
throw ClientConfigurationError.createInvalidCloudDiscoveryMetadataError();
|
||
}
|
||
}
|
||
// If cloudDiscoveryMetadata is empty or does not contain the host, check knownAuthorities
|
||
if (this.isInKnownAuthorities()) {
|
||
return Authority.createCloudDiscoveryMetadataFromHost(this.hostnameAndPort);
|
||
}
|
||
return null;
|
||
};
|
||
/**
|
||
* Called to get metadata from network if CloudDiscoveryMetadata was not populated by config
|
||
* @param networkInterface
|
||
*/
|
||
Authority.prototype.getCloudDiscoveryMetadataFromNetwork = function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var instanceDiscoveryEndpoint, match, response, metadata, e_2;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
instanceDiscoveryEndpoint = "" + Constants.AAD_INSTANCE_DISCOVERY_ENDPT + this.canonicalAuthority + "oauth2/v2.0/authorize";
|
||
match = null;
|
||
_a.label = 1;
|
||
case 1:
|
||
_a.trys.push([1, 3, , 4]);
|
||
return [4 /*yield*/, this.networkInterface.sendGetRequestAsync(instanceDiscoveryEndpoint)];
|
||
case 2:
|
||
response = _a.sent();
|
||
metadata = isCloudInstanceDiscoveryResponse(response.body) ? response.body.metadata : [];
|
||
match = Authority.getCloudDiscoveryMetadataFromNetworkResponse(metadata, this.hostnameAndPort);
|
||
return [3 /*break*/, 4];
|
||
case 3:
|
||
e_2 = _a.sent();
|
||
return [2 /*return*/, null];
|
||
case 4:
|
||
if (!match) {
|
||
// Custom Domain scenario, host is trusted because Instance Discovery call succeeded
|
||
match = Authority.createCloudDiscoveryMetadataFromHost(this.hostnameAndPort);
|
||
}
|
||
return [2 /*return*/, match];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Helper function to determine if this host is included in the knownAuthorities config option
|
||
*/
|
||
Authority.prototype.isInKnownAuthorities = function () {
|
||
var _this = this;
|
||
var matches = this.authorityOptions.knownAuthorities.filter(function (authority) {
|
||
return UrlString.getDomainFromUrl(authority).toLowerCase() === _this.hostnameAndPort;
|
||
});
|
||
return matches.length > 0;
|
||
};
|
||
/**
|
||
* Creates cloud discovery metadata object from a given host
|
||
* @param host
|
||
*/
|
||
Authority.createCloudDiscoveryMetadataFromHost = function (host) {
|
||
return {
|
||
preferred_network: host,
|
||
preferred_cache: host,
|
||
aliases: [host]
|
||
};
|
||
};
|
||
/**
|
||
* Searches instance discovery network response for the entry that contains the host in the aliases list
|
||
* @param response
|
||
* @param authority
|
||
*/
|
||
Authority.getCloudDiscoveryMetadataFromNetworkResponse = function (response, authority) {
|
||
for (var i = 0; i < response.length; i++) {
|
||
var metadata = response[i];
|
||
if (metadata.aliases.indexOf(authority) > -1) {
|
||
return metadata;
|
||
}
|
||
}
|
||
return null;
|
||
};
|
||
/**
|
||
* helper function to generate environment from authority object
|
||
*/
|
||
Authority.prototype.getPreferredCache = function () {
|
||
if (this.discoveryComplete()) {
|
||
return this.metadata.preferred_cache;
|
||
}
|
||
else {
|
||
throw ClientAuthError.createEndpointDiscoveryIncompleteError("Discovery incomplete.");
|
||
}
|
||
};
|
||
/**
|
||
* Returns whether or not the provided host is an alias of this authority instance
|
||
* @param host
|
||
*/
|
||
Authority.prototype.isAlias = function (host) {
|
||
return this.metadata.aliases.indexOf(host) > -1;
|
||
};
|
||
return Authority;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var AuthorityFactory = /** @class */ (function () {
|
||
function AuthorityFactory() {
|
||
}
|
||
/**
|
||
* Create an authority object of the correct type based on the url
|
||
* Performs basic authority validation - checks to see if the authority is of a valid type (i.e. aad, b2c, adfs)
|
||
*
|
||
* Also performs endpoint discovery.
|
||
*
|
||
* @param authorityUri
|
||
* @param networkClient
|
||
* @param protocolMode
|
||
*/
|
||
AuthorityFactory.createDiscoveredInstance = function (authorityUri, networkClient, cacheManager, authorityOptions) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var acquireTokenAuthority, e_1;
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
acquireTokenAuthority = AuthorityFactory.createInstance(authorityUri, networkClient, cacheManager, authorityOptions);
|
||
_a.label = 1;
|
||
case 1:
|
||
_a.trys.push([1, 3, , 4]);
|
||
return [4 /*yield*/, acquireTokenAuthority.resolveEndpointsAsync()];
|
||
case 2:
|
||
_a.sent();
|
||
return [2 /*return*/, acquireTokenAuthority];
|
||
case 3:
|
||
e_1 = _a.sent();
|
||
throw ClientAuthError.createEndpointDiscoveryIncompleteError(e_1);
|
||
case 4: return [2 /*return*/];
|
||
}
|
||
});
|
||
});
|
||
};
|
||
/**
|
||
* Create an authority object of the correct type based on the url
|
||
* Performs basic authority validation - checks to see if the authority is of a valid type (i.e. aad, b2c, adfs)
|
||
*
|
||
* Does not perform endpoint discovery.
|
||
*
|
||
* @param authorityUrl
|
||
* @param networkInterface
|
||
* @param protocolMode
|
||
*/
|
||
AuthorityFactory.createInstance = function (authorityUrl, networkInterface, cacheManager, authorityOptions) {
|
||
// Throw error if authority url is empty
|
||
if (StringUtils.isEmpty(authorityUrl)) {
|
||
throw ClientConfigurationError.createUrlEmptyError();
|
||
}
|
||
return new Authority(authorityUrl, networkInterface, cacheManager, authorityOptions);
|
||
};
|
||
return AuthorityFactory;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var ServerTelemetryEntity = /** @class */ (function () {
|
||
function ServerTelemetryEntity() {
|
||
this.failedRequests = [];
|
||
this.errors = [];
|
||
this.cacheHits = 0;
|
||
}
|
||
/**
|
||
* validates if a given cache entry is "Telemetry", parses <key,value>
|
||
* @param key
|
||
* @param entity
|
||
*/
|
||
ServerTelemetryEntity.isServerTelemetryEntity = function (key, entity) {
|
||
var validateKey = key.indexOf(SERVER_TELEM_CONSTANTS.CACHE_KEY) === 0;
|
||
var validateEntity = true;
|
||
if (entity) {
|
||
validateEntity =
|
||
entity.hasOwnProperty("failedRequests") &&
|
||
entity.hasOwnProperty("errors") &&
|
||
entity.hasOwnProperty("cacheHits");
|
||
}
|
||
return validateKey && validateEntity;
|
||
};
|
||
return ServerTelemetryEntity;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var ThrottlingEntity = /** @class */ (function () {
|
||
function ThrottlingEntity() {
|
||
}
|
||
/**
|
||
* validates if a given cache entry is "Throttling", parses <key,value>
|
||
* @param key
|
||
* @param entity
|
||
*/
|
||
ThrottlingEntity.isThrottlingEntity = function (key, entity) {
|
||
var validateKey = false;
|
||
if (key) {
|
||
validateKey = key.indexOf(ThrottlingConstants.THROTTLING_PREFIX) === 0;
|
||
}
|
||
var validateEntity = true;
|
||
if (entity) {
|
||
validateEntity = entity.hasOwnProperty("throttleTime");
|
||
}
|
||
return validateKey && validateEntity;
|
||
};
|
||
return ThrottlingEntity;
|
||
}());
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var StubbedNetworkModule = {
|
||
sendGetRequestAsync: function () {
|
||
var notImplErr = "Network interface - sendGetRequestAsync() has not been implemented for the Network interface.";
|
||
return Promise.reject(AuthError.createUnexpectedError(notImplErr));
|
||
},
|
||
sendPostRequestAsync: function () {
|
||
var notImplErr = "Network interface - sendPostRequestAsync() has not been implemented for the Network interface.";
|
||
return Promise.reject(AuthError.createUnexpectedError(notImplErr));
|
||
}
|
||
};
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
var ServerTelemetryManager = /** @class */ (function () {
|
||
function ServerTelemetryManager(telemetryRequest, cacheManager) {
|
||
this.cacheManager = cacheManager;
|
||
this.apiId = telemetryRequest.apiId;
|
||
this.correlationId = telemetryRequest.correlationId;
|
||
this.forceRefresh = telemetryRequest.forceRefresh || false;
|
||
this.wrapperSKU = telemetryRequest.wrapperSKU || Constants.EMPTY_STRING;
|
||
this.wrapperVer = telemetryRequest.wrapperVer || Constants.EMPTY_STRING;
|
||
this.telemetryCacheKey = SERVER_TELEM_CONSTANTS.CACHE_KEY + Separators.CACHE_KEY_SEPARATOR + telemetryRequest.clientId;
|
||
}
|
||
/**
|
||
* API to add MSER Telemetry to request
|
||
*/
|
||
ServerTelemetryManager.prototype.generateCurrentRequestHeaderValue = function () {
|
||
var forceRefreshInt = this.forceRefresh ? 1 : 0;
|
||
var request = "" + this.apiId + SERVER_TELEM_CONSTANTS.VALUE_SEPARATOR + forceRefreshInt;
|
||
var platformFields = [this.wrapperSKU, this.wrapperVer].join(SERVER_TELEM_CONSTANTS.VALUE_SEPARATOR);
|
||
return [SERVER_TELEM_CONSTANTS.SCHEMA_VERSION, request, platformFields].join(SERVER_TELEM_CONSTANTS.CATEGORY_SEPARATOR);
|
||
};
|
||
/**
|
||
* API to add MSER Telemetry for the last failed request
|
||
*/
|
||
ServerTelemetryManager.prototype.generateLastRequestHeaderValue = function () {
|
||
var lastRequests = this.getLastRequests();
|
||
var maxErrors = ServerTelemetryManager.maxErrorsToSend(lastRequests);
|
||
var failedRequests = lastRequests.failedRequests.slice(0, 2 * maxErrors).join(SERVER_TELEM_CONSTANTS.VALUE_SEPARATOR);
|
||
var errors = lastRequests.errors.slice(0, maxErrors).join(SERVER_TELEM_CONSTANTS.VALUE_SEPARATOR);
|
||
var errorCount = lastRequests.errors.length;
|
||
// Indicate whether this header contains all data or partial data
|
||
var overflow = maxErrors < errorCount ? SERVER_TELEM_CONSTANTS.OVERFLOW_TRUE : SERVER_TELEM_CONSTANTS.OVERFLOW_FALSE;
|
||
var platformFields = [errorCount, overflow].join(SERVER_TELEM_CONSTANTS.VALUE_SEPARATOR);
|
||
return [SERVER_TELEM_CONSTANTS.SCHEMA_VERSION, lastRequests.cacheHits, failedRequests, errors, platformFields].join(SERVER_TELEM_CONSTANTS.CATEGORY_SEPARATOR);
|
||
};
|
||
/**
|
||
* API to cache token failures for MSER data capture
|
||
* @param error
|
||
*/
|
||
ServerTelemetryManager.prototype.cacheFailedRequest = function (error) {
|
||
var lastRequests = this.getLastRequests();
|
||
lastRequests.failedRequests.push(this.apiId, this.correlationId);
|
||
if (!StringUtils.isEmpty(error.subError)) {
|
||
lastRequests.errors.push(error.subError);
|
||
}
|
||
else if (!StringUtils.isEmpty(error.errorCode)) {
|
||
lastRequests.errors.push(error.errorCode);
|
||
}
|
||
else if (!!error && error.toString()) {
|
||
lastRequests.errors.push(error.toString());
|
||
}
|
||
else {
|
||
lastRequests.errors.push(SERVER_TELEM_CONSTANTS.UNKNOWN_ERROR);
|
||
}
|
||
this.cacheManager.setServerTelemetry(this.telemetryCacheKey, lastRequests);
|
||
return;
|
||
};
|
||
/**
|
||
* Update server telemetry cache entry by incrementing cache hit counter
|
||
*/
|
||
ServerTelemetryManager.prototype.incrementCacheHits = function () {
|
||
var lastRequests = this.getLastRequests();
|
||
lastRequests.cacheHits += 1;
|
||
this.cacheManager.setServerTelemetry(this.telemetryCacheKey, lastRequests);
|
||
return lastRequests.cacheHits;
|
||
};
|
||
/**
|
||
* Get the server telemetry entity from cache or initialize a new one
|
||
*/
|
||
ServerTelemetryManager.prototype.getLastRequests = function () {
|
||
var initialValue = new ServerTelemetryEntity();
|
||
var lastRequests = this.cacheManager.getServerTelemetry(this.telemetryCacheKey);
|
||
return lastRequests || initialValue;
|
||
};
|
||
/**
|
||
* Remove server telemetry cache entry
|
||
*/
|
||
ServerTelemetryManager.prototype.clearTelemetryCache = function () {
|
||
var lastRequests = this.getLastRequests();
|
||
var numErrorsFlushed = ServerTelemetryManager.maxErrorsToSend(lastRequests);
|
||
var errorCount = lastRequests.errors.length;
|
||
if (numErrorsFlushed === errorCount) {
|
||
// All errors were sent on last request, clear Telemetry cache
|
||
this.cacheManager.removeItem(this.telemetryCacheKey);
|
||
}
|
||
else {
|
||
// Partial data was flushed to server, construct a new telemetry cache item with errors that were not flushed
|
||
var serverTelemEntity = new ServerTelemetryEntity();
|
||
serverTelemEntity.failedRequests = lastRequests.failedRequests.slice(numErrorsFlushed * 2); // failedRequests contains 2 items for each error
|
||
serverTelemEntity.errors = lastRequests.errors.slice(numErrorsFlushed);
|
||
this.cacheManager.setServerTelemetry(this.telemetryCacheKey, serverTelemEntity);
|
||
}
|
||
};
|
||
/**
|
||
* Returns the maximum number of errors that can be flushed to the server in the next network request
|
||
* @param serverTelemetryEntity
|
||
*/
|
||
ServerTelemetryManager.maxErrorsToSend = function (serverTelemetryEntity) {
|
||
var i;
|
||
var maxErrors = 0;
|
||
var dataSize = 0;
|
||
var errorCount = serverTelemetryEntity.errors.length;
|
||
for (i = 0; i < errorCount; i++) {
|
||
// failedRequests parameter contains pairs of apiId and correlationId, multiply index by 2 to preserve pairs
|
||
var apiId = serverTelemetryEntity.failedRequests[2 * i] || Constants.EMPTY_STRING;
|
||
var correlationId = serverTelemetryEntity.failedRequests[2 * i + 1] || Constants.EMPTY_STRING;
|
||
var errorCode = serverTelemetryEntity.errors[i] || Constants.EMPTY_STRING;
|
||
// Count number of characters that would be added to header, each character is 1 byte. Add 3 at the end to account for separators
|
||
dataSize += apiId.toString().length + correlationId.toString().length + errorCode.length + 3;
|
||
if (dataSize < SERVER_TELEM_CONSTANTS.MAX_HEADER_BYTES) {
|
||
// Adding this entry to the header would still keep header size below the limit
|
||
maxErrors += 1;
|
||
}
|
||
else {
|
||
break;
|
||
}
|
||
}
|
||
return maxErrors;
|
||
};
|
||
return ServerTelemetryManager;
|
||
}());
|
||
|
||
export { AccessTokenEntity, AccountEntity, AppMetadataEntity, AuthError, AuthErrorMessage, AuthToken, AuthenticationScheme, Authority, AuthorityFactory, AuthorityMetadataEntity, AuthorityType, AuthorizationCodeClient, CacheAccountType, CacheManager, CacheSchemaType, CacheType, ClientAuthError, ClientAuthErrorMessage, ClientConfigurationError, ClientConfigurationErrorMessage, ClientCredentialClient, Constants, CredentialEntity, CredentialType, DEFAULT_CRYPTO_IMPLEMENTATION, DEFAULT_SYSTEM_OPTIONS, DefaultStorageClass, DeviceCodeClient, AuthToken as IdToken, IdTokenEntity, InteractionRequiredAuthError, LogLevel, Logger, NetworkManager, OIDC_DEFAULT_SCOPES, OnBehalfOfClient, PersistentCacheKeys, PromptValue, ProtocolMode, ProtocolUtils, RefreshTokenClient, RefreshTokenEntity, ResponseMode, ServerError, ServerTelemetryEntity, ServerTelemetryManager, SilentFlowClient, StringUtils, StubbedNetworkModule, ThrottlingEntity, ThrottlingUtils, TimeUtils, TokenCacheContext, UrlString, UsernamePasswordClient };
|
||
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.es.js","sources":["../src/utils/Constants.ts","../src/error/AuthError.ts","../src/crypto/ICrypto.ts","../src/error/ClientAuthError.ts","../src/utils/StringUtils.ts","../src/logger/Logger.ts","../src/packageMetadata.ts","../src/cache/entities/CredentialEntity.ts","../src/error/ClientConfigurationError.ts","../src/request/ScopeSet.ts","../src/account/ClientInfo.ts","../src/authority/AuthorityType.ts","../src/cache/entities/AccountEntity.ts","../src/account/AuthToken.ts","../src/cache/CacheManager.ts","../src/config/ClientConfiguration.ts","../src/error/ServerError.ts","../src/network/ThrottlingUtils.ts","../src/network/NetworkManager.ts","../src/client/BaseClient.ts","../src/request/RequestValidator.ts","../src/request/RequestParameterBuilder.ts","../src/cache/entities/IdTokenEntity.ts","../src/utils/TimeUtils.ts","../src/cache/entities/AccessTokenEntity.ts","../src/cache/entities/RefreshTokenEntity.ts","../src/error/InteractionRequiredAuthError.ts","../src/cache/entities/CacheRecord.ts","../src/utils/ProtocolUtils.ts","../src/url/UrlString.ts","../src/crypto/PopTokenGenerator.ts","../src/cache/entities/AppMetadataEntity.ts","../src/cache/persistence/TokenCacheContext.ts","../src/response/ResponseHandler.ts","../src/client/AuthorizationCodeClient.ts","../src/client/DeviceCodeClient.ts","../src/client/RefreshTokenClient.ts","../src/client/ClientCredentialClient.ts","../src/client/OnBehalfOfClient.ts","../src/client/SilentFlowClient.ts","../src/client/UsernamePasswordClient.ts","../src/authority/OpenIdConfigResponse.ts","../src/authority/ProtocolMode.ts","../src/cache/entities/AuthorityMetadataEntity.ts","../src/authority/CloudInstanceDiscoveryResponse.ts","../src/authority/Authority.ts","../src/authority/AuthorityFactory.ts","../src/cache/entities/ServerTelemetryEntity.ts","../src/cache/entities/ThrottlingEntity.ts","../src/network/INetworkModule.ts","../src/telemetry/server/ServerTelemetryManager.ts"],"sourcesContent":["/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nexport const Constants = {\r\n    LIBRARY_NAME: \"MSAL.JS\",\r\n    SKU: \"msal.js.common\",\r\n    // Prefix for all library cache entries\r\n    CACHE_PREFIX: \"msal\",\r\n    // default authority\r\n    DEFAULT_AUTHORITY: \"https://login.microsoftonline.com/common/\",\r\n    DEFAULT_AUTHORITY_HOST: \"login.microsoftonline.com\",\r\n    // ADFS String\r\n    ADFS: \"adfs\",\r\n    // Default AAD Instance Discovery Endpoint\r\n    AAD_INSTANCE_DISCOVERY_ENDPT: \"https://login.microsoftonline.com/common/discovery/instance?api-version=1.1&authorization_endpoint=\",\r\n    // Resource delimiter - used for certain cache entries\r\n    RESOURCE_DELIM: \"|\",\r\n    // Placeholder for non-existent account ids/objects\r\n    NO_ACCOUNT: \"NO_ACCOUNT\",\r\n    // Claims\r\n    CLAIMS: \"claims\",\r\n    // Consumer UTID\r\n    CONSUMER_UTID: \"9188040d-6c67-4c5b-b112-36a304b66dad\",\r\n    // Default scopes\r\n    OPENID_SCOPE: \"openid\",\r\n    PROFILE_SCOPE: \"profile\",\r\n    OFFLINE_ACCESS_SCOPE: \"offline_access\",\r\n    EMAIL_SCOPE: \"email\",\r\n    // Default response type for authorization code flow\r\n    CODE_RESPONSE_TYPE: \"code\",\r\n    CODE_GRANT_TYPE: \"authorization_code\",\r\n    RT_GRANT_TYPE: \"refresh_token\",\r\n    FRAGMENT_RESPONSE_MODE: \"fragment\",\r\n    S256_CODE_CHALLENGE_METHOD: \"S256\",\r\n    URL_FORM_CONTENT_TYPE: \"application/x-www-form-urlencoded;charset=utf-8\",\r\n    AUTHORIZATION_PENDING: \"authorization_pending\",\r\n    NOT_DEFINED: \"not_defined\",\r\n    EMPTY_STRING: \"\",\r\n    FORWARD_SLASH: \"/\"\r\n};\r\n\r\nexport const OIDC_DEFAULT_SCOPES = [\r\n    Constants.OPENID_SCOPE,\r\n    Constants.PROFILE_SCOPE,\r\n    Constants.OFFLINE_ACCESS_SCOPE\r\n];\r\n\r\nexport const OIDC_SCOPES = [\r\n    ...OIDC_DEFAULT_SCOPES,\r\n    Constants.EMAIL_SCOPE\r\n];\r\n\r\n/**\r\n * Request header names\r\n */\r\nexport enum HeaderNames {\r\n    CONTENT_TYPE = \"Content-Type\",\r\n    X_CLIENT_CURR_TELEM = \"x-client-current-telemetry\",\r\n    X_CLIENT_LAST_TELEM = \"x-client-last-telemetry\",\r\n    RETRY_AFTER = \"Retry-After\",\r\n    X_MS_LIB_CAPABILITY = \"x-ms-lib-capability\",\r\n    X_MS_LIB_CAPABILITY_VALUE = \"retry-after, h429\"\r\n}\r\n\r\n/**\r\n * Persistent cache keys MSAL which stay while user is logged in.\r\n */\r\nexport enum PersistentCacheKeys {\r\n    ID_TOKEN = \"idtoken\",\r\n    CLIENT_INFO = \"client.info\",\r\n    ADAL_ID_TOKEN = \"adal.idtoken\",\r\n    ERROR = \"error\",\r\n    ERROR_DESC = \"error.description\"\r\n}\r\n\r\n/**\r\n * String constants related to AAD Authority\r\n */\r\nexport enum AADAuthorityConstants {\r\n    COMMON = \"common\",\r\n    ORGANIZATIONS = \"organizations\",\r\n    CONSUMERS = \"consumers\"\r\n}\r\n\r\n/**\r\n * Keys in the hashParams sent by AAD Server\r\n */\r\nexport enum AADServerParamKeys {\r\n    CLIENT_ID = \"client_id\",\r\n    REDIRECT_URI = \"redirect_uri\",\r\n    RESPONSE_TYPE = \"response_type\",\r\n    RESPONSE_MODE = \"response_mode\",\r\n    GRANT_TYPE = \"grant_type\",\r\n    CLAIMS = \"claims\",\r\n    SCOPE = \"scope\",\r\n    ERROR = \"error\",\r\n    ERROR_DESCRIPTION = \"error_description\",\r\n    ACCESS_TOKEN = \"access_token\",\r\n    ID_TOKEN = \"id_token\",\r\n    REFRESH_TOKEN = \"refresh_token\",\r\n    EXPIRES_IN = \"expires_in\",\r\n    STATE = \"state\",\r\n    NONCE = \"nonce\",\r\n    PROMPT = \"prompt\",\r\n    SESSION_STATE = \"session_state\",\r\n    CLIENT_INFO = \"client_info\",\r\n    CODE = \"code\",\r\n    CODE_CHALLENGE = \"code_challenge\",\r\n    CODE_CHALLENGE_METHOD = \"code_challenge_method\",\r\n    CODE_VERIFIER = \"code_verifier\",\r\n    CLIENT_REQUEST_ID = \"client-request-id\",\r\n    X_CLIENT_SKU = \"x-client-SKU\",\r\n    X_CLIENT_VER = \"x-client-VER\",\r\n    X_CLIENT_OS = \"x-client-OS\",\r\n    X_CLIENT_CPU = \"x-client-CPU\",\r\n    POST_LOGOUT_URI = \"post_logout_redirect_uri\",\r\n    ID_TOKEN_HINT= \"id_token_hint\",\r\n    DEVICE_CODE = \"device_code\",\r\n    CLIENT_SECRET = \"client_secret\",\r\n    CLIENT_ASSERTION = \"client_assertion\",\r\n    CLIENT_ASSERTION_TYPE = \"client_assertion_type\",\r\n    TOKEN_TYPE = \"token_type\",\r\n    REQ_CNF = \"req_cnf\",\r\n    OBO_ASSERTION = \"assertion\",\r\n    REQUESTED_TOKEN_USE = \"requested_token_use\",\r\n    ON_BEHALF_OF = \"on_behalf_of\",\r\n    FOCI = \"foci\"\r\n}\r\n\r\n/**\r\n * Claims request keys\r\n */\r\nexport enum ClaimsRequestKeys {\r\n    ACCESS_TOKEN = \"access_token\",\r\n    XMS_CC = \"xms_cc\"\r\n}\r\n\r\n/**\r\n * we considered making this \"enum\" in the request instead of string, however it looks like the allowed list of\r\n * prompt values kept changing over past couple of years. There are some undocumented prompt values for some\r\n * internal partners too, hence the choice of generic \"string\" type instead of the \"enum\"\r\n */\r\nexport const PromptValue = {\r\n    LOGIN: \"login\",\r\n    SELECT_ACCOUNT: \"select_account\",\r\n    CONSENT: \"consent\",\r\n    NONE: \"none\",\r\n};\r\n\r\n/**\r\n * SSO Types - generated to populate hints\r\n */\r\nexport enum SSOTypes {\r\n    ACCOUNT = \"account\",\r\n    SID = \"sid\",\r\n    LOGIN_HINT = \"login_hint\",\r\n    ID_TOKEN = \"id_token\",\r\n    DOMAIN_HINT = \"domain_hint\",\r\n    ORGANIZATIONS = \"organizations\",\r\n    CONSUMERS = \"consumers\",\r\n    ACCOUNT_ID = \"accountIdentifier\",\r\n    HOMEACCOUNT_ID = \"homeAccountIdentifier\"\r\n}\r\n\r\n/**\r\n * Disallowed extra query parameters.\r\n */\r\nexport const BlacklistedEQParams = [\r\n    SSOTypes.SID,\r\n    SSOTypes.LOGIN_HINT\r\n];\r\n\r\n/**\r\n * allowed values for codeVerifier\r\n */\r\nexport const CodeChallengeMethodValues = {\r\n    PLAIN: \"plain\",\r\n    S256: \"S256\"\r\n};\r\n\r\n/**\r\n * The method used to encode the code verifier for the code challenge parameter. can be one\r\n * of plain or s256. if excluded, code challenge is assumed to be plaintext. for more\r\n * information, see the pkce rcf: https://tools.ietf.org/html/rfc7636\r\n */\r\nexport const CodeChallengeMethodValuesArray: string[] = [\r\n    CodeChallengeMethodValues.PLAIN,\r\n    CodeChallengeMethodValues.S256\r\n];\r\n\r\n/**\r\n * allowed values for response_mode\r\n */\r\nexport enum ResponseMode {\r\n    QUERY = \"query\",\r\n    FRAGMENT = \"fragment\",\r\n    FORM_POST = \"form_post\"\r\n}\r\n\r\n/**\r\n * allowed grant_type\r\n */\r\nexport enum GrantType {\r\n    IMPLICIT_GRANT = \"implicit\",\r\n    AUTHORIZATION_CODE_GRANT = \"authorization_code\",\r\n    CLIENT_CREDENTIALS_GRANT = \"client_credentials\",\r\n    RESOURCE_OWNER_PASSWORD_GRANT = \"password\",\r\n    REFRESH_TOKEN_GRANT = \"refresh_token\",\r\n    DEVICE_CODE_GRANT = \"device_code\",\r\n    JWT_BEARER = \"urn:ietf:params:oauth:grant-type:jwt-bearer\"\r\n}\r\n\r\n/**\r\n * Account types in Cache\r\n */\r\nexport enum CacheAccountType {\r\n    MSSTS_ACCOUNT_TYPE = \"MSSTS\",\r\n    ADFS_ACCOUNT_TYPE = \"ADFS\",\r\n    MSAV1_ACCOUNT_TYPE = \"MSA\",\r\n    GENERIC_ACCOUNT_TYPE = \"Generic\" // NTLM, Kerberos, FBA, Basic etc\r\n}\r\n\r\n/**\r\n * Separators used in cache\r\n */\r\nexport enum Separators {\r\n    CACHE_KEY_SEPARATOR = \"-\",\r\n    CLIENT_INFO_SEPARATOR = \".\"\r\n}\r\n\r\n/**\r\n * Credential Type stored in the cache\r\n */\r\nexport enum CredentialType {\r\n    ID_TOKEN = \"IdToken\",\r\n    ACCESS_TOKEN = \"AccessToken\",\r\n    REFRESH_TOKEN = \"RefreshToken\",\r\n}\r\n\r\n/**\r\n * Credential Type stored in the cache\r\n */\r\nexport enum CacheSchemaType {\r\n    ACCOUNT = \"Account\",\r\n    CREDENTIAL = \"Credential\",\r\n    ID_TOKEN = \"IdToken\",\r\n    ACCESS_TOKEN = \"AccessToken\",\r\n    REFRESH_TOKEN = \"RefreshToken\",\r\n    APP_METADATA = \"AppMetadata\",\r\n    TEMPORARY = \"TempCache\",\r\n    TELEMETRY = \"Telemetry\",\r\n    UNDEFINED = \"Undefined\",\r\n    THROTTLING = \"Throttling\"\r\n}\r\n\r\n/**\r\n * Combine all cache types\r\n */\r\nexport enum CacheType {\r\n    ADFS = 1001,\r\n    MSA = 1002,\r\n    MSSTS = 1003,\r\n    GENERIC = 1004,\r\n    ACCESS_TOKEN = 2001,\r\n    REFRESH_TOKEN = 2002,\r\n    ID_TOKEN = 2003,\r\n    APP_METADATA = 3001,\r\n    UNDEFINED = 9999\r\n}\r\n\r\n/**\r\n * More Cache related constants\r\n */\r\nexport const APP_METADATA = \"appmetadata\";\r\nexport const ClientInfo = \"client_info\";\r\nexport const THE_FAMILY_ID = \"1\";\r\n\r\nexport const AUTHORITY_METADATA_CONSTANTS = {\r\n    CACHE_KEY: \"authority-metadata\",\r\n    REFRESH_TIME_SECONDS: 3600 * 24 // 24 Hours\r\n};\r\n\r\nexport enum AuthorityMetadataSource {\r\n    CONFIG = \"config\",\r\n    CACHE = \"cache\",\r\n    NETWORK = \"network\"\r\n}\r\n\r\nexport const SERVER_TELEM_CONSTANTS = {\r\n    SCHEMA_VERSION: 2,\r\n    MAX_HEADER_BYTES: 4000, // Max is 4KB, 4000 Bytes provides 96 Byte buffer for separators, schema version, etc. \r\n    CACHE_KEY: \"server-telemetry\",\r\n    CATEGORY_SEPARATOR: \"|\",\r\n    VALUE_SEPARATOR: \",\",\r\n    OVERFLOW_TRUE: \"1\",\r\n    OVERFLOW_FALSE: \"0\",\r\n    UNKNOWN_ERROR: \"unknown_error\"\r\n};\r\n\r\n/**\r\n * Type of the authentication request\r\n */\r\nexport enum AuthenticationScheme {\r\n    POP = \"pop\",\r\n    BEARER = \"Bearer\"\r\n}\r\n\r\n/**\r\n * Constants related to throttling\r\n */\r\nexport const ThrottlingConstants = {\r\n    // Default time to throttle RequestThumbprint in seconds\r\n    DEFAULT_THROTTLE_TIME_SECONDS: 60,\r\n    // Default maximum time to throttle in seconds, overrides what the server sends back\r\n    DEFAULT_MAX_THROTTLE_TIME_SECONDS: 3600,\r\n    // Prefix for storing throttling entries\r\n    THROTTLING_PREFIX: \"throttling\"\r\n};\r\n\r\nexport const Errors = {\r\n    INVALID_GRANT_ERROR: \"invalid_grant\",\r\n    CLIENT_MISMATCH_ERROR: \"client_mismatch\",\r\n};\r\n\r\n/**\r\n * Password grant parameters\r\n */\r\nexport enum PasswordGrantConstants {\r\n    username = \"username\",\r\n    password = \"password\"\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { Constants } from \"../utils/Constants\";\r\n\r\n/**\r\n * AuthErrorMessage class containing string constants used by error codes and messages.\r\n */\r\nexport const AuthErrorMessage = {\r\n    unexpectedError: {\r\n        code: \"unexpected_error\",\r\n        desc: \"Unexpected error in authentication.\"\r\n    }\r\n};\r\n\r\n/**\r\n * General error class thrown by the MSAL.js library.\r\n */\r\nexport class AuthError extends Error {\r\n\r\n    /**\r\n     * Short string denoting error\r\n     */\r\n    errorCode: string;\r\n\r\n    /**\r\n     * Detailed description of error\r\n     */\r\n    errorMessage: string;\r\n\r\n    /**\r\n     * Describes the subclass of an error\r\n     */\r\n    subError: string;\r\n\r\n    constructor(errorCode?: string, errorMessage?: string, suberror?: string) {\r\n        const errorString = errorMessage ? `${errorCode}: ${errorMessage}` : errorCode;\r\n        super(errorString);\r\n        Object.setPrototypeOf(this, AuthError.prototype);\r\n\r\n        this.errorCode = errorCode || Constants.EMPTY_STRING;\r\n        this.errorMessage = errorMessage || \"\";\r\n        this.subError = suberror || \"\";\r\n        this.name = \"AuthError\";\r\n    }\r\n\r\n    /**\r\n     * Creates an error that is thrown when something unexpected happens in the library.\r\n     * @param errDesc\r\n     */\r\n    static createUnexpectedError(errDesc: string): AuthError {\r\n        return new AuthError(AuthErrorMessage.unexpectedError.code, `${AuthErrorMessage.unexpectedError.desc}: ${errDesc}`);\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { AuthError } from \"../error/AuthError\";\r\nimport { SignedHttpRequest } from \"./SignedHttpRequest\";\r\n\r\n/**\r\n * The PkceCodes type describes the structure\r\n * of objects that contain PKCE code\r\n * challenge and verifier pairs\r\n */\r\nexport type PkceCodes = {\r\n    verifier: string,\r\n    challenge: string\r\n};\r\n\r\n/**\r\n * Interface for crypto functions used by library\r\n */\r\nexport interface ICrypto {\r\n    /**\r\n     * Creates a guid randomly.\r\n     */\r\n    createNewGuid(): string;\r\n    /**\r\n     * base64 Encode string\r\n     * @param input \r\n     */\r\n    base64Encode(input: string): string;\r\n    /**\r\n     * base64 decode string\r\n     * @param input \r\n     */\r\n    base64Decode(input: string): string;\r\n    /**\r\n     * Generate PKCE codes for OAuth. See RFC here: https://tools.ietf.org/html/rfc7636\r\n     */\r\n    generatePkceCodes(): Promise<PkceCodes>;\r\n    /**\r\n     * Generates an JWK RSA S256 Thumbprint\r\n     * @param resourceRequestMethod \r\n     * @param resourceRequestUri \r\n     */\r\n    getPublicKeyThumbprint(resourceRequestMethod: string, resourceRequestUri: string): Promise<string>;\r\n    /** \r\n     * Returns a signed proof-of-possession token with a given acces token that contains a cnf claim with the required kid.\r\n     * @param accessToken \r\n     */\r\n    signJwt(payload: SignedHttpRequest, kid: string): Promise<string>;\r\n}\r\n\r\nexport const DEFAULT_CRYPTO_IMPLEMENTATION: ICrypto = {\r\n    createNewGuid: (): string => {\r\n        const notImplErr = \"Crypto interface - createNewGuid() has not been implemented\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    },\r\n    base64Decode: (): string => {\r\n        const notImplErr = \"Crypto interface - base64Decode() has not been implemented\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    },\r\n    base64Encode: (): string => {\r\n        const notImplErr = \"Crypto interface - base64Encode() has not been implemented\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    },\r\n    async generatePkceCodes(): Promise<PkceCodes> {\r\n        const notImplErr = \"Crypto interface - generatePkceCodes() has not been implemented\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    },\r\n    async getPublicKeyThumbprint(): Promise<string> {\r\n        const notImplErr = \"Crypto interface - getPublicKeyThumbprint() has not been implemented\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    },\r\n    async signJwt(): Promise<string> {\r\n        const notImplErr = \"Crypto interface - signJwt() has not been implemented\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n};\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { AuthError } from \"./AuthError\";\r\nimport { ScopeSet } from \"../request/ScopeSet\";\r\n\r\n/**\r\n * ClientAuthErrorMessage class containing string constants used by error codes and messages.\r\n */\r\nexport const ClientAuthErrorMessage = {\r\n    clientInfoDecodingError: {\r\n        code: \"client_info_decoding_error\",\r\n        desc: \"The client info could not be parsed/decoded correctly. Please review the trace to determine the root cause.\"\r\n    },\r\n    clientInfoEmptyError: {\r\n        code: \"client_info_empty_error\",\r\n        desc: \"The client info was empty. Please review the trace to determine the root cause.\"\r\n    },\r\n    tokenParsingError: {\r\n        code: \"token_parsing_error\",\r\n        desc: \"Token cannot be parsed. Please review stack trace to determine root cause.\"\r\n    },\r\n    nullOrEmptyToken: {\r\n        code: \"null_or_empty_token\",\r\n        desc: \"The token is null or empty. Please review the trace to determine the root cause.\"\r\n    },\r\n    endpointResolutionError: {\r\n        code: \"endpoints_resolution_error\",\r\n        desc: \"Error: could not resolve endpoints. Please check network and try again.\"\r\n    },\r\n    unableToGetOpenidConfigError: {\r\n        code: \"openid_config_error\",\r\n        desc: \"Could not retrieve endpoints. Check your authority and verify the .well-known/openid-configuration endpoint returns the required endpoints.\"\r\n    },\r\n    hashNotDeserialized: {\r\n        code: \"hash_not_deserialized\",\r\n        desc: \"The hash parameters could not be deserialized. Please review the trace to determine the root cause.\"\r\n    },\r\n    blankGuidGenerated: {\r\n        code: \"blank_guid_generated\",\r\n        desc: \"The guid generated was blank. Please review the trace to determine the root cause.\"\r\n    },\r\n    invalidStateError: {\r\n        code: \"invalid_state\",\r\n        desc: \"State was not the expected format. Please check the logs to determine whether the request was sent using ProtocolUtils.setRequestState().\"\r\n    },\r\n    stateMismatchError: {\r\n        code: \"state_mismatch\",\r\n        desc: \"State mismatch error. Please check your network. Continued requests may cause cache overflow.\"\r\n    },\r\n    stateNotFoundError: {\r\n        code: \"state_not_found\",\r\n        desc: \"State not found\"\r\n    },\r\n    nonceMismatchError: {\r\n        code: \"nonce_mismatch\",\r\n        desc: \"Nonce mismatch error. This may be caused by a race condition in concurrent requests.\"\r\n    },\r\n    nonceNotFoundError: {\r\n        code: \"nonce_not_found\",\r\n        desc: \"nonce not found\"\r\n    },\r\n    noTokensFoundError: {\r\n        code: \"no_tokens_found\",\r\n        desc: \"No tokens were found for the given scopes, and no authorization code was passed to acquireToken. You must retrieve an authorization code before making a call to acquireToken().\"\r\n    },\r\n    multipleMatchingTokens: {\r\n        code: \"multiple_matching_tokens\",\r\n        desc: \"The cache contains multiple tokens satisfying the requirements. \" +\r\n            \"Call AcquireToken again providing more requirements such as authority or account.\"\r\n    },\r\n    multipleMatchingAccounts: {\r\n        code: \"multiple_matching_accounts\",\r\n        desc: \"The cache contains multiple accounts satisfying the given parameters. Please pass more info to obtain the correct account\"\r\n    },\r\n    multipleMatchingAppMetadata: {\r\n        code: \"multiple_matching_appMetadata\",\r\n        desc: \"The cache contains multiple appMetadata satisfying the given parameters. Please pass more info to obtain the correct appMetadata\"\r\n    },\r\n    tokenRequestCannotBeMade: {\r\n        code: \"request_cannot_be_made\",\r\n        desc: \"Token request cannot be made without authorization code or refresh token.\"\r\n    },\r\n    appendEmptyScopeError: {\r\n        code: \"cannot_append_empty_scope\",\r\n        desc: \"Cannot append null or empty scope to ScopeSet. Please check the stack trace for more info.\"\r\n    },\r\n    removeEmptyScopeError: {\r\n        code: \"cannot_remove_empty_scope\",\r\n        desc: \"Cannot remove null or empty scope from ScopeSet. Please check the stack trace for more info.\"\r\n    },\r\n    appendScopeSetError: {\r\n        code: \"cannot_append_scopeset\",\r\n        desc: \"Cannot append ScopeSet due to error.\"\r\n    },\r\n    emptyInputScopeSetError: {\r\n        code: \"empty_input_scopeset\",\r\n        desc: \"Empty input ScopeSet cannot be processed.\"\r\n    },\r\n    DeviceCodePollingCancelled: {\r\n        code: \"device_code_polling_cancelled\",\r\n        desc: \"Caller has cancelled token endpoint polling during device code flow by setting DeviceCodeRequest.cancel = true.\"\r\n    },\r\n    DeviceCodeExpired: {\r\n        code: \"device_code_expired\",\r\n        desc: \"Device code is expired.\"\r\n    },\r\n    NoAccountInSilentRequest: {\r\n        code: \"no_account_in_silent_request\",\r\n        desc: \"Please pass an account object, silent flow is not supported without account information\"\r\n    },\r\n    invalidCacheRecord: {\r\n        code: \"invalid_cache_record\",\r\n        desc: \"Cache record object was null or undefined.\"\r\n    },\r\n    invalidCacheEnvironment: {\r\n        code: \"invalid_cache_environment\",\r\n        desc: \"Invalid environment when attempting to create cache entry\"\r\n    },\r\n    noAccountFound: {\r\n        code: \"no_account_found\",\r\n        desc: \"No account found in cache for given key.\"\r\n    },\r\n    CachePluginError: {\r\n        code: \"no cache plugin set on CacheManager\",\r\n        desc: \"ICachePlugin needs to be set before using readFromStorage or writeFromStorage\"\r\n    },\r\n    noCryptoObj: {\r\n        code: \"no_crypto_object\",\r\n        desc: \"No crypto object detected. This is required for the following operation: \"\r\n    },\r\n    invalidCacheType: {\r\n        code: \"invalid_cache_type\",\r\n        desc: \"Invalid cache type\"\r\n    },\r\n    unexpectedAccountType: {\r\n        code: \"unexpected_account_type\",\r\n        desc: \"Unexpected account type.\"\r\n    },\r\n    unexpectedCredentialType: {\r\n        code: \"unexpected_credential_type\",\r\n        desc: \"Unexpected credential type.\"\r\n    },\r\n    invalidAssertion: {\r\n        code: \"invalid_assertion\",\r\n        desc: \"Client assertion must meet requirements described in https://tools.ietf.org/html/rfc7515\"\r\n    },\r\n    invalidClientCredential: {\r\n        code: \"invalid_client_credential\",\r\n        desc: \"Client credential (secret, certificate, or assertion) must not be empty when creating a confidential client. An application should at most have one credential\"\r\n    },\r\n    tokenRefreshRequired: {\r\n        code: \"token_refresh_required\",\r\n        desc: \"Cannot return token from cache because it must be refreshed. This may be due to one of the following reasons: forceRefresh parameter is set to true, claims have been requested, there is no cached access token or it is expired.\"\r\n    },\r\n    userTimeoutReached: {\r\n        code: \"user_timeout_reached\",\r\n        desc: \"User defined timeout for device code polling reached\",\r\n    },\r\n    tokenClaimsRequired: {\r\n        code: \"token_claims_cnf_required_for_signedjwt\",\r\n        desc: \"Cannot generate a POP jwt if the token_claims are not populated\"\r\n    },\r\n    noAuthorizationCodeFromServer: {\r\n        code: \"authorization_code_missing_from_server_response\",\r\n        desc: \"Srver response does not contain an authorization code to proceed\"\r\n    }\r\n};\r\n\r\n/**\r\n * Error thrown when there is an error in the client code running on the browser.\r\n */\r\nexport class ClientAuthError extends AuthError {\r\n\r\n    constructor(errorCode: string, errorMessage?: string) {\r\n        super(errorCode, errorMessage);\r\n        this.name = \"ClientAuthError\";\r\n\r\n        Object.setPrototypeOf(this, ClientAuthError.prototype);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when client info object doesn't decode correctly.\r\n     * @param caughtError\r\n     */\r\n    static createClientInfoDecodingError(caughtError: string): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.clientInfoDecodingError.code,\r\n            `${ClientAuthErrorMessage.clientInfoDecodingError.desc} Failed with error: ${caughtError}`);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown if the client info is empty.\r\n     * @param rawClientInfo\r\n     */\r\n    static createClientInfoEmptyError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.clientInfoEmptyError.code,\r\n            `${ClientAuthErrorMessage.clientInfoEmptyError.desc}`);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when the id token extraction errors out.\r\n     * @param err\r\n     */\r\n    static createTokenParsingError(caughtExtractionError: string): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.tokenParsingError.code,\r\n            `${ClientAuthErrorMessage.tokenParsingError.desc} Failed with error: ${caughtExtractionError}`);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when the id token string is null or empty.\r\n     * @param invalidRawTokenString\r\n     */\r\n    static createTokenNullOrEmptyError(invalidRawTokenString: string) : ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.nullOrEmptyToken.code,\r\n            `${ClientAuthErrorMessage.nullOrEmptyToken.desc} Raw Token Value: ${invalidRawTokenString}`);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when the endpoint discovery doesn't complete correctly.\r\n     */\r\n    static createEndpointDiscoveryIncompleteError(errDetail: string): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.endpointResolutionError.code,\r\n            `${ClientAuthErrorMessage.endpointResolutionError.desc} Detail: ${errDetail}`);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when the openid-configuration endpoint cannot be reached or does not contain the required data\r\n     */\r\n    static createUnableToGetOpenidConfigError(errDetail: string): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.unableToGetOpenidConfigError.code,\r\n            `${ClientAuthErrorMessage.unableToGetOpenidConfigError.desc} Attempted to retrieve endpoints from: ${errDetail}`);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when the hash cannot be deserialized.\r\n     * @param hashParamObj\r\n     */\r\n    static createHashNotDeserializedError(hashParamObj: string): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.hashNotDeserialized.code,\r\n            `${ClientAuthErrorMessage.hashNotDeserialized.desc} Given Object: ${hashParamObj}`);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when the state cannot be parsed.\r\n     * @param invalidState\r\n     */\r\n    static createInvalidStateError(invalidState: string, errorString?: string): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.invalidStateError.code,\r\n            `${ClientAuthErrorMessage.invalidStateError.desc} Invalid State: ${invalidState}, Root Err: ${errorString}`);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when two states do not match.\r\n     */\r\n    static createStateMismatchError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.stateMismatchError.code,\r\n            ClientAuthErrorMessage.stateMismatchError.desc);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when the state is not present\r\n     * @param missingState\r\n     */\r\n    static createStateNotFoundError(missingState: string): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.stateNotFoundError.code,\r\n            `${ClientAuthErrorMessage.stateNotFoundError.desc}:  ${missingState}`);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when the nonce does not match.\r\n     */\r\n    static createNonceMismatchError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.nonceMismatchError.code,\r\n            ClientAuthErrorMessage.nonceMismatchError.desc);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when the mnonce is not present\r\n     * @param missingNonce\r\n     */\r\n    static createNonceNotFoundError(missingNonce: string): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.nonceNotFoundError.code,\r\n            `${ClientAuthErrorMessage.nonceNotFoundError.desc}:  ${missingNonce}`);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when the authorization code required for a token request is null or empty.\r\n     */\r\n    static createNoTokensFoundError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.noTokensFoundError.code, ClientAuthErrorMessage.noTokensFoundError.desc);\r\n    }\r\n\r\n    /**\r\n     * Throws error when multiple tokens are in cache.\r\n     */\r\n    static createMultipleMatchingTokensInCacheError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.multipleMatchingTokens.code,\r\n            `${ClientAuthErrorMessage.multipleMatchingTokens.desc}.`);\r\n    }\r\n\r\n    /**\r\n     * Throws error when multiple accounts are in cache for the given params\r\n     */\r\n    static createMultipleMatchingAccountsInCacheError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.multipleMatchingAccounts.code,\r\n            ClientAuthErrorMessage.multipleMatchingAccounts.desc);\r\n    }\r\n\r\n    /**\r\n     * Throws error when multiple appMetada are in cache for the given clientId.\r\n     */\r\n    static createMultipleMatchingAppMetadataInCacheError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.multipleMatchingAppMetadata.code,\r\n            ClientAuthErrorMessage.multipleMatchingAppMetadata.desc);\r\n    }\r\n\r\n    /**\r\n     * Throws error when no auth code or refresh token is given to ServerTokenRequestParameters.\r\n     */\r\n    static createTokenRequestCannotBeMadeError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.tokenRequestCannotBeMade.code, ClientAuthErrorMessage.tokenRequestCannotBeMade.desc);\r\n    }\r\n\r\n    /**\r\n     * Throws error when attempting to append a null, undefined or empty scope to a set\r\n     * @param givenScope\r\n     */\r\n    static createAppendEmptyScopeToSetError(givenScope: string): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.appendEmptyScopeError.code, `${ClientAuthErrorMessage.appendEmptyScopeError.desc} Given Scope: ${givenScope}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error when attempting to append a null, undefined or empty scope to a set\r\n     * @param givenScope\r\n     */\r\n    static createRemoveEmptyScopeFromSetError(givenScope: string): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.removeEmptyScopeError.code, `${ClientAuthErrorMessage.removeEmptyScopeError.desc} Given Scope: ${givenScope}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error when attempting to append null or empty ScopeSet.\r\n     * @param appendError\r\n     */\r\n    static createAppendScopeSetError(appendError: string): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.appendScopeSetError.code, `${ClientAuthErrorMessage.appendScopeSetError.desc} Detail Error: ${appendError}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error if ScopeSet is null or undefined.\r\n     * @param givenScopeSet\r\n     */\r\n    static createEmptyInputScopeSetError(givenScopeSet: ScopeSet): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.emptyInputScopeSetError.code, `${ClientAuthErrorMessage.emptyInputScopeSetError.desc} Given ScopeSet: ${givenScopeSet}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error if user sets CancellationToken.cancel = true during polling of token endpoint during device code flow\r\n     */\r\n    static createDeviceCodeCancelledError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.DeviceCodePollingCancelled.code, `${ClientAuthErrorMessage.DeviceCodePollingCancelled.desc}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error if device code is expired\r\n     */\r\n    static createDeviceCodeExpiredError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.DeviceCodeExpired.code, `${ClientAuthErrorMessage.DeviceCodeExpired.desc}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error when silent requests are made without an account object\r\n     */\r\n    static createNoAccountInSilentRequestError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.NoAccountInSilentRequest.code, `${ClientAuthErrorMessage.NoAccountInSilentRequest.desc}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error when cache record is null or undefined.\r\n     */\r\n    static createNullOrUndefinedCacheRecord(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.invalidCacheRecord.code, ClientAuthErrorMessage.invalidCacheRecord.desc);\r\n    }\r\n\r\n    /**\r\n     * Throws error when provided environment is not part of the CloudDiscoveryMetadata object\r\n     */\r\n    static createInvalidCacheEnvironmentError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.invalidCacheEnvironment.code, ClientAuthErrorMessage.invalidCacheEnvironment.desc);\r\n    }\r\n\r\n    /**\r\n     * Throws error when account is not found in cache.\r\n     */\r\n    static createNoAccountFoundError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.noAccountFound.code, ClientAuthErrorMessage.noAccountFound.desc);\r\n    }\r\n\r\n    /**\r\n     * Throws error if ICachePlugin not set on CacheManager.\r\n     */\r\n    static createCachePluginError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.CachePluginError.code, `${ClientAuthErrorMessage.CachePluginError.desc}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error if crypto object not found.\r\n     * @param operationName\r\n     */\r\n    static createNoCryptoObjectError(operationName: string): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.noCryptoObj.code, `${ClientAuthErrorMessage.noCryptoObj.desc}${operationName}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error if cache type is invalid.\r\n     */\r\n    static createInvalidCacheTypeError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.invalidCacheType.code, `${ClientAuthErrorMessage.invalidCacheType.desc}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error if unexpected account type.\r\n     */\r\n    static createUnexpectedAccountTypeError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.unexpectedAccountType.code, `${ClientAuthErrorMessage.unexpectedAccountType.desc}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error if unexpected credential type.\r\n     */\r\n    static createUnexpectedCredentialTypeError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.unexpectedCredentialType.code, `${ClientAuthErrorMessage.unexpectedCredentialType.desc}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error if client assertion is not valid.\r\n     */\r\n    static createInvalidAssertionError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.invalidAssertion.code, `${ClientAuthErrorMessage.invalidAssertion.desc}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error if client assertion is not valid.\r\n     */\r\n    static createInvalidCredentialError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.invalidClientCredential.code, `${ClientAuthErrorMessage.invalidClientCredential.desc}`);\r\n    }\r\n\r\n    /**\r\n     * Throws error if token cannot be retrieved from cache due to refresh being required.\r\n     */\r\n    static createRefreshRequiredError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.tokenRefreshRequired.code, ClientAuthErrorMessage.tokenRefreshRequired.desc);\r\n    }\r\n\r\n    /**\r\n     * Throws error if the user defined timeout is reached.\r\n     */\r\n    static createUserTimeoutReachedError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.userTimeoutReached.code, ClientAuthErrorMessage.userTimeoutReached.desc);\r\n    }\r\n\r\n    /*\r\n     * Throws error if token claims are not populated for a signed jwt generation\r\n     */\r\n    static createTokenClaimsRequiredError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.tokenClaimsRequired.code, ClientAuthErrorMessage.tokenClaimsRequired.desc);\r\n    }\r\n\r\n    /**\r\n     * Throws error when the authorization code is missing from the server response\r\n     */\r\n    static createNoAuthCodeInServerResponseError(): ClientAuthError {\r\n        return new ClientAuthError(ClientAuthErrorMessage.noAuthorizationCodeFromServer.code, ClientAuthErrorMessage.noAuthorizationCodeFromServer.desc);\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { DecodedAuthToken } from \"../account/DecodedAuthToken\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\n\r\n/**\r\n * @hidden\r\n */\r\nexport class StringUtils {\r\n\r\n    /**\r\n     * decode a JWT\r\n     *\r\n     * @param authToken\r\n     */\r\n    static decodeAuthToken(authToken: string): DecodedAuthToken {\r\n        if (StringUtils.isEmpty(authToken)) {\r\n            throw ClientAuthError.createTokenNullOrEmptyError(authToken);\r\n        }\r\n        const tokenPartsRegex = /^([^\\.\\s]*)\\.([^\\.\\s]+)\\.([^\\.\\s]*)$/;\r\n        const matches = tokenPartsRegex.exec(authToken);\r\n        if (!matches || matches.length < 4) {\r\n            throw ClientAuthError.createTokenParsingError(`Given token is malformed: ${JSON.stringify(authToken)}`);\r\n        }\r\n        const crackedToken: DecodedAuthToken = {\r\n            header: matches[1],\r\n            JWSPayload: matches[2],\r\n            JWSSig: matches[3]\r\n        };\r\n        return crackedToken;\r\n    }\r\n\r\n    /**\r\n     * Check if a string is empty.\r\n     *\r\n     * @param str\r\n     */\r\n    static isEmpty(str?: string): boolean {\r\n        return (typeof str === \"undefined\" || !str || 0 === str.length);\r\n    }\r\n\r\n    static startsWith(str: string, search: string): boolean {\r\n        return str.indexOf(search) === 0;\r\n    }\r\n\r\n    static endsWith(str: string, search: string): boolean {\r\n        return (str.length >= search.length) && (str.lastIndexOf(search) === (str.length - search.length));\r\n    }\r\n\r\n    /**\r\n     * Parses string into an object.\r\n     *\r\n     * @param query\r\n     */\r\n    static queryStringToObject<T>(query: string): T {\r\n        let match: Array<string> | null; // Regex for replacing addition symbol with a space\r\n        const pl = /\\+/g;\r\n        const search = /([^&=]+)=([^&]*)/g;\r\n        const decode = (s: string): string => decodeURIComponent(decodeURIComponent(s.replace(pl, \" \")));\r\n        const obj: {} = {};\r\n        match = search.exec(query);\r\n        while (match) {\r\n            obj[decode(match[1])] = decode(match[2]);\r\n            match = search.exec(query);\r\n        }\r\n        return obj as T;\r\n    }\r\n\r\n    /**\r\n     * Trims entries in an array.\r\n     *\r\n     * @param arr\r\n     */\r\n    static trimArrayEntries(arr: Array<string>): Array<string> {\r\n        return arr.map(entry => entry.trim());\r\n    }\r\n\r\n    /**\r\n     * Removes empty strings from array\r\n     * @param arr\r\n     */\r\n    static removeEmptyStringsFromArray(arr: Array<string>): Array<string> {\r\n        return arr.filter(entry => {\r\n            return !StringUtils.isEmpty(entry);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Attempts to parse a string into JSON\r\n     * @param str\r\n     */\r\n    static jsonParseHelper<T>(str: string): T | null {\r\n        try {\r\n            return JSON.parse(str) as T;\r\n        } catch (e) {\r\n            return null;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Tests if a given string matches a given pattern, with support for wildcards.\r\n     * @param pattern Wildcard pattern to string match. Supports \"*\" for wildcards\r\n     * @param input String to match against\r\n     */\r\n    static matchPattern(pattern: string, input: string): boolean {\r\n        // https://stackoverflow.com/a/3117248/4888559\r\n        const regex: RegExp = new RegExp(pattern.replace(/\\*/g, \"[^ ]*\"));\r\n\r\n        return regex.test(input);\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\nimport { LoggerOptions } from \"../config/ClientConfiguration\";\r\nimport { Constants } from \"../utils/Constants\";\r\n\r\n/**\r\n * Options for logger messages.\r\n */\r\nexport type LoggerMessageOptions = {\r\n    logLevel: LogLevel,\r\n    correlationId?: string,\r\n    containsPii?: boolean,\r\n    context?: string\r\n};\r\n\r\n/**\r\n * Log message level.\r\n */\r\nexport enum LogLevel {\r\n    Error,\r\n    Warning,\r\n    Info,\r\n    Verbose\r\n}\r\n\r\n/**\r\n * Callback to send the messages to.\r\n */\r\nexport interface ILoggerCallback {\r\n    (level: LogLevel, message: string, containsPii: boolean): void;\r\n}\r\n\r\n/**\r\n * Class which facilitates logging of messages to a specific place.\r\n */\r\nexport class Logger {\r\n\r\n    // Correlation ID for request, usually set by user.\r\n    private correlationId: string;\r\n\r\n    // Current log level, defaults to info.\r\n    private level: LogLevel = LogLevel.Info;\r\n\r\n    // Boolean describing whether PII logging is allowed.\r\n    private piiLoggingEnabled: boolean;\r\n\r\n    // Callback to send messages to.\r\n    private localCallback: ILoggerCallback;\r\n\r\n    // Package name implementing this logger\r\n    private packageName: string;\r\n\r\n    // Package version implementing this logger\r\n    private packageVersion: string;\r\n\r\n    constructor(loggerOptions: LoggerOptions, packageName?: string, packageVersion?: string) {\r\n        const defaultLoggerCallback = () => {};\r\n        this.localCallback = loggerOptions.loggerCallback || defaultLoggerCallback;\r\n        this.piiLoggingEnabled = loggerOptions.piiLoggingEnabled || false;\r\n        this.level = loggerOptions.logLevel || LogLevel.Info;\r\n\r\n        this.packageName = packageName || Constants.EMPTY_STRING;\r\n        this.packageVersion = packageVersion || Constants.EMPTY_STRING;\r\n    }\r\n\r\n    /**\r\n     * Create new Logger with existing configurations.\r\n     */\r\n    public clone(packageName: string, packageVersion: string): Logger {\r\n        return new Logger({loggerCallback: this.localCallback, piiLoggingEnabled: this.piiLoggingEnabled, logLevel: this.level}, packageName, packageVersion);\r\n    }\r\n\r\n    /**\r\n     * Log message with required options.\r\n     */\r\n    private logMessage(logMessage: string, options: LoggerMessageOptions): void {\r\n        if ((options.logLevel > this.level) || (!this.piiLoggingEnabled && options.containsPii)) {\r\n            return;\r\n        }\r\n        const timestamp = new Date().toUTCString();\r\n        const logHeader: string = StringUtils.isEmpty(this.correlationId) ? `[${timestamp}] : ` : `[${timestamp}] : [${this.correlationId}]`;\r\n        const log = `${logHeader} : ${this.packageName}@${this.packageVersion} : ${LogLevel[options.logLevel]} - ${logMessage}`;\r\n        // debug(`msal:${LogLevel[options.logLevel]}${options.containsPii ? \"-Pii\": \"\"}${options.context ? `:${options.context}` : \"\"}`)(logMessage);\r\n        this.executeCallback(options.logLevel, log, options.containsPii || false);\r\n    }\r\n\r\n    /**\r\n     * Execute callback with message.\r\n     */\r\n    executeCallback(level: LogLevel, message: string, containsPii: boolean): void {\r\n        if (this.localCallback) {\r\n            this.localCallback(level, message, containsPii);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Logs error messages.\r\n     */\r\n    error(message: string, correlationId?: string): void {\r\n        this.logMessage(message, {\r\n            logLevel: LogLevel.Error,\r\n            containsPii: false,\r\n            correlationId: correlationId || \"\"\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Logs error messages with PII.\r\n     */\r\n    errorPii(message: string, correlationId?: string): void {\r\n        this.logMessage(message, {\r\n            logLevel: LogLevel.Error,\r\n            containsPii: true,\r\n            correlationId: correlationId || \"\"\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Logs warning messages.\r\n     */\r\n    warning(message: string, correlationId?: string): void {\r\n        this.logMessage(message, {\r\n            logLevel: LogLevel.Warning,\r\n            containsPii: false,\r\n            correlationId: correlationId || \"\"\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Logs warning messages with PII.\r\n     */\r\n    warningPii(message: string, correlationId?: string): void {\r\n        this.logMessage(message, {\r\n            logLevel: LogLevel.Warning,\r\n            containsPii: true,\r\n            correlationId: correlationId || \"\"\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Logs info messages.\r\n     */\r\n    info(message: string, correlationId?: string): void {\r\n        this.logMessage(message, {\r\n            logLevel: LogLevel.Info,\r\n            containsPii: false,\r\n            correlationId: correlationId || \"\"\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Logs info messages with PII.\r\n     */\r\n    infoPii(message: string, correlationId?: string): void {\r\n        this.logMessage(message, {\r\n            logLevel: LogLevel.Info,\r\n            containsPii: true,\r\n            correlationId: correlationId || \"\"\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Logs verbose messages.\r\n     */\r\n    verbose(message: string, correlationId?: string): void {\r\n        this.logMessage(message, {\r\n            logLevel: LogLevel.Verbose,\r\n            containsPii: false,\r\n            correlationId: correlationId || \"\"\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Logs verbose messages with PII.\r\n     */\r\n    verbosePii(message: string, correlationId?: string): void {\r\n        this.logMessage(message, {\r\n            logLevel: LogLevel.Verbose,\r\n            containsPii: true,\r\n            correlationId: correlationId || \"\"\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Returns whether PII Logging is enabled or not.\r\n     */\r\n    isPiiLoggingEnabled(): boolean {\r\n        return this.piiLoggingEnabled || false;\r\n    }\r\n}\r\n","/* eslint-disable header/header */\nexport const name = \"@azure/msal-common\";\nexport const version = \"4.0.1\";\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { Separators, CredentialType, CacheType, Constants } from \"../../utils/Constants\";\r\nimport { ClientAuthError } from \"../../error/ClientAuthError\";\r\n\r\n/**\r\n * Base type for credentials to be stored in the cache: eg: ACCESS_TOKEN, ID_TOKEN etc\r\n *\r\n * Key:Value Schema:\r\n *\r\n * Key: <home_account_id*>-<environment>-<credential_type>-<client_id>-<realm*>-<target*>\r\n *\r\n * Value Schema:\r\n * {\r\n *      homeAccountId: home account identifier for the auth scheme,\r\n *      environment: entity that issued the token, represented as a full host\r\n *      credentialType: Type of credential as a string, can be one of the following: RefreshToken, AccessToken, IdToken, Password, Cookie, Certificate, Other\r\n *      clientId: client ID of the application\r\n *      secret: Actual credential as a string\r\n *      familyId: Family ID identifier, usually only used for refresh tokens\r\n *      realm: Full tenant or organizational identifier that the account belongs to\r\n *      target: Permissions that are included in the token, or for refresh tokens, the resource identifier.\r\n *      oboAssertion: access token passed in as part of OBO request\r\n * }\r\n */\r\nexport class CredentialEntity {\r\n    homeAccountId: string;\r\n    environment: string;\r\n    credentialType: CredentialType;\r\n    clientId: string;\r\n    secret: string;\r\n    familyId?: string;\r\n    realm?: string;\r\n    target?: string;\r\n    oboAssertion?: string;\r\n\r\n    /**\r\n     * Generate Account Id key component as per the schema: <home_account_id>-<environment>\r\n     */\r\n    generateAccountId(): string {\r\n        return CredentialEntity.generateAccountIdForCacheKey(this.homeAccountId, this.environment);\r\n    }\r\n\r\n    /**\r\n     * Generate Credential Id key component as per the schema: <credential_type>-<client_id>-<realm>\r\n     */\r\n    generateCredentialId(): string {\r\n        return CredentialEntity.generateCredentialIdForCacheKey(\r\n            this.credentialType,\r\n            this.clientId,\r\n            this.realm,\r\n            this.familyId\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Generate target key component as per schema: <target>\r\n     */\r\n    generateTarget(): string {\r\n        return CredentialEntity.generateTargetForCacheKey(this.target);\r\n    }\r\n\r\n    /**\r\n     * generates credential key\r\n     */\r\n    generateCredentialKey(): string {\r\n        return CredentialEntity.generateCredentialCacheKey(\r\n            this.homeAccountId,\r\n            this.environment,\r\n            this.credentialType,\r\n            this.clientId,\r\n            this.realm,\r\n            this.target,\r\n            this.familyId\r\n        );\r\n    }\r\n\r\n    /**\r\n     * returns the type of the cache (in this case credential)\r\n     */\r\n    generateType(): number {\r\n        switch (this.credentialType) {\r\n            case CredentialType.ID_TOKEN:\r\n                return CacheType.ID_TOKEN;\r\n            case CredentialType.ACCESS_TOKEN:\r\n                return CacheType.ACCESS_TOKEN;\r\n            case CredentialType.REFRESH_TOKEN:\r\n                return CacheType.REFRESH_TOKEN;\r\n            default: {\r\n                throw ClientAuthError.createUnexpectedCredentialTypeError();\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * helper function to return `CredentialType`\r\n     * @param key\r\n     */\r\n    static getCredentialType(key: string): string {\r\n        if (key.indexOf(CredentialType.ACCESS_TOKEN.toLowerCase()) !== -1) {\r\n            return CredentialType.ACCESS_TOKEN;\r\n        } else if (key.indexOf(CredentialType.ID_TOKEN.toLowerCase()) !== -1) {\r\n            return CredentialType.ID_TOKEN;\r\n        } else if (key.indexOf(CredentialType.REFRESH_TOKEN.toLowerCase()) !== -1) {\r\n            return CredentialType.REFRESH_TOKEN;\r\n        }\r\n\r\n        return Constants.NOT_DEFINED;\r\n    }\r\n\r\n    /**\r\n     * generates credential key\r\n     */\r\n    static generateCredentialCacheKey(\r\n        homeAccountId: string,\r\n        environment: string,\r\n        credentialType: CredentialType,\r\n        clientId: string,\r\n        realm?: string,\r\n        target?: string,\r\n        familyId?: string\r\n    ): string {\r\n        const credentialKey = [\r\n            this.generateAccountIdForCacheKey(homeAccountId, environment),\r\n            this.generateCredentialIdForCacheKey(credentialType, clientId, realm, familyId),\r\n            this.generateTargetForCacheKey(target),\r\n        ];\r\n\r\n        return credentialKey.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();\r\n    }\r\n\r\n    /**\r\n     * generates Account Id for keys\r\n     * @param homeAccountId\r\n     * @param environment\r\n     */\r\n    private static generateAccountIdForCacheKey(\r\n        homeAccountId: string,\r\n        environment: string\r\n    ): string {\r\n        const accountId: Array<string> = [homeAccountId, environment];\r\n        return accountId.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();\r\n    }\r\n\r\n    /**\r\n     * Generates Credential Id for keys\r\n     * @param credentialType\r\n     * @param realm\r\n     * @param clientId\r\n     * @param familyId\r\n     */\r\n    private static generateCredentialIdForCacheKey(\r\n        credentialType: CredentialType,\r\n        clientId: string,\r\n        realm?: string,\r\n        familyId?: string\r\n    ): string {\r\n        const clientOrFamilyId =\r\n            credentialType === CredentialType.REFRESH_TOKEN\r\n                ? familyId || clientId\r\n                : clientId;\r\n        const credentialId: Array<string> = [\r\n            credentialType,\r\n            clientOrFamilyId,\r\n            realm || \"\",\r\n        ];\r\n\r\n        return credentialId.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();\r\n    }\r\n\r\n    /**\r\n     * Generate target key component as per schema: <target>\r\n     */\r\n    private static generateTargetForCacheKey(scopes?: string): string {\r\n        return (scopes || \"\").toLowerCase();\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { ClientAuthError } from \"./ClientAuthError\";\r\n\r\n/**\r\n * ClientConfigurationErrorMessage class containing string constants used by error codes and messages.\r\n */\r\nexport const ClientConfigurationErrorMessage = {\r\n    redirectUriNotSet: {\r\n        code: \"redirect_uri_empty\",\r\n        desc: \"A redirect URI is required for all calls, and none has been set.\"\r\n    },\r\n    postLogoutUriNotSet: {\r\n        code: \"post_logout_uri_empty\",\r\n        desc: \"A post logout redirect has not been set.\"\r\n    },\r\n    claimsRequestParsingError: {\r\n        code: \"claims_request_parsing_error\",\r\n        desc: \"Could not parse the given claims request object.\"\r\n    },\r\n    authorityUriInsecure: {\r\n        code: \"authority_uri_insecure\",\r\n        desc: \"Authority URIs must use https.  Please see here for valid authority configuration options: https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-js-initializing-client-applications#configuration-options\"\r\n    },\r\n    urlParseError: {\r\n        code: \"url_parse_error\",\r\n        desc: \"URL could not be parsed into appropriate segments.\"\r\n    },\r\n    urlEmptyError: {\r\n        code: \"empty_url_error\",\r\n        desc: \"URL was empty or null.\"\r\n    },\r\n    emptyScopesError: {\r\n        code: \"empty_input_scopes_error\",\r\n        desc: \"Scopes cannot be passed as null, undefined or empty array because they are required to obtain an access token.\"\r\n    },\r\n    nonArrayScopesError: {\r\n        code: \"nonarray_input_scopes_error\",\r\n        desc: \"Scopes cannot be passed as non-array.\"\r\n    },\r\n    clientIdSingleScopeError: {\r\n        code: \"clientid_input_scopes_error\",\r\n        desc: \"Client ID can only be provided as a single scope.\"\r\n    },\r\n    invalidPrompt: {\r\n        code: \"invalid_prompt_value\",\r\n        desc: \"Supported prompt values are 'login', 'select_account', 'consent' and 'none'.  Please see here for valid configuration options: https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-js-initializing-client-applications#configuration-options\",\r\n    },\r\n    invalidClaimsRequest: {\r\n        code: \"invalid_claims\",\r\n        desc: \"Given claims parameter must be a stringified JSON object.\"\r\n    },\r\n    tokenRequestEmptyError: {\r\n        code: \"token_request_empty\",\r\n        desc: \"Token request was empty and not found in cache.\"\r\n    },\r\n    logoutRequestEmptyError: {\r\n        code: \"logout_request_empty\",\r\n        desc: \"The logout request was null or undefined.\"\r\n    },\r\n    invalidCodeChallengeMethod: {\r\n        code: \"invalid_code_challenge_method\",\r\n        desc: \"code_challenge_method passed is invalid. Valid values are \\\"plain\\\" and \\\"S256\\\".\"\r\n    },\r\n    invalidCodeChallengeParams: {\r\n        code: \"pkce_params_missing\",\r\n        desc: \"Both params: code_challenge and code_challenge_method are to be passed if to be sent in the request\"\r\n    },\r\n    invalidCloudDiscoveryMetadata: {\r\n        code: \"invalid_cloud_discovery_metadata\",\r\n        desc: \"Invalid cloudDiscoveryMetadata provided. Must be a JSON object containing tenant_discovery_endpoint and metadata fields\"\r\n    },\r\n    invalidAuthorityMetadata: {\r\n        code: \"invalid_authority_metadata\",\r\n        desc: \"Invalid authorityMetadata provided. Must by a JSON object containing authorization_endpoint, token_endpoint, end_session_endpoint, issuer fields.\"\r\n    },\r\n    untrustedAuthority: {\r\n        code: \"untrusted_authority\",\r\n        desc: \"The provided authority is not a trusted authority. Please include this authority in the knownAuthorities config parameter.\"\r\n    },\r\n    resourceRequestParametersRequired: {\r\n        code: \"resourceRequest_parameters_required\",\r\n        desc: \"resourceRequestMethod and resourceRequestUri are required\"\r\n    }\r\n};\r\n\r\n/**\r\n * Error thrown when there is an error in configuration of the MSAL.js library.\r\n */\r\nexport class ClientConfigurationError extends ClientAuthError {\r\n\r\n    constructor(errorCode: string, errorMessage?: string) {\r\n        super(errorCode, errorMessage);\r\n        this.name = \"ClientConfigurationError\";\r\n        Object.setPrototypeOf(this, ClientConfigurationError.prototype);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when the redirect uri is empty (not set by caller)\r\n     */\r\n    static createRedirectUriEmptyError(): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.redirectUriNotSet.code,\r\n            ClientConfigurationErrorMessage.redirectUriNotSet.desc);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when the post-logout redirect uri is empty (not set by caller)\r\n     */\r\n    static createPostLogoutRedirectUriEmptyError(): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.postLogoutUriNotSet.code,\r\n            ClientConfigurationErrorMessage.postLogoutUriNotSet.desc);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown when the claims request could not be successfully parsed\r\n     */\r\n    static createClaimsRequestParsingError(claimsRequestParseError: string): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.claimsRequestParsingError.code,\r\n            `${ClientConfigurationErrorMessage.claimsRequestParsingError.desc} Given value: ${claimsRequestParseError}`);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown if authority uri is given an insecure protocol.\r\n     * @param urlString\r\n     */\r\n    static createInsecureAuthorityUriError(urlString: string): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.authorityUriInsecure.code,\r\n            `${ClientConfigurationErrorMessage.authorityUriInsecure.desc} Given URI: ${urlString}`);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown if URL string does not parse into separate segments.\r\n     * @param urlString\r\n     */\r\n    static createUrlParseError(urlParseError: string): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.urlParseError.code,\r\n            `${ClientConfigurationErrorMessage.urlParseError.desc} Given Error: ${urlParseError}`);\r\n    }\r\n\r\n    /**\r\n     * Creates an error thrown if URL string is empty or null.\r\n     * @param urlString\r\n     */\r\n    static createUrlEmptyError(): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.urlEmptyError.code,\r\n            ClientConfigurationErrorMessage.urlEmptyError.desc);\r\n    }\r\n\r\n    /**\r\n     * Error thrown when scopes are not an array\r\n     * @param inputScopes\r\n     */\r\n    static createScopesNonArrayError(inputScopes: Array<string>): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.nonArrayScopesError.code,\r\n            `${ClientConfigurationErrorMessage.nonArrayScopesError.desc} Given Scopes: ${inputScopes}`);\r\n    }\r\n\r\n    /**\r\n     * Error thrown when scopes are empty.\r\n     * @param scopesValue\r\n     */\r\n    static createEmptyScopesArrayError(inputScopes: Array<string>): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.emptyScopesError.code,\r\n            `${ClientConfigurationErrorMessage.emptyScopesError.desc} Given Scopes: ${inputScopes}`);\r\n    }\r\n\r\n    /**\r\n     * Error thrown when client id scope is not provided as single scope.\r\n     * @param inputScopes\r\n     */\r\n    static createClientIdSingleScopeError(inputScopes: Array<string>): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.clientIdSingleScopeError.code,\r\n            `${ClientConfigurationErrorMessage.clientIdSingleScopeError.desc} Given Scopes: ${inputScopes}`);\r\n    }\r\n\r\n    /**\r\n     * Error thrown when prompt is not an allowed type.\r\n     * @param promptValue\r\n     */\r\n    static createInvalidPromptError(promptValue: string): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.invalidPrompt.code,\r\n            `${ClientConfigurationErrorMessage.invalidPrompt.desc} Given value: ${promptValue}`);\r\n    }\r\n\r\n    /**\r\n     * Creates error thrown when claims parameter is not a stringified JSON object\r\n     */\r\n    static createInvalidClaimsRequestError(): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.invalidClaimsRequest.code,\r\n            ClientConfigurationErrorMessage.invalidClaimsRequest.desc);\r\n    }\r\n\r\n    /**\r\n     * Throws error when token request is empty and nothing cached in storage.\r\n     */\r\n    static createEmptyLogoutRequestError(): ClientConfigurationError {\r\n        return new ClientConfigurationError(\r\n            ClientConfigurationErrorMessage.logoutRequestEmptyError.code,\r\n            ClientConfigurationErrorMessage.logoutRequestEmptyError.desc\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Throws error when token request is empty and nothing cached in storage.\r\n     */\r\n    static createEmptyTokenRequestError(): ClientConfigurationError {\r\n        return new ClientConfigurationError(\r\n            ClientConfigurationErrorMessage.tokenRequestEmptyError.code,\r\n            ClientConfigurationErrorMessage.tokenRequestEmptyError.desc\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Throws error when an invalid code_challenge_method is passed by the user\r\n     */\r\n    static createInvalidCodeChallengeMethodError(): ClientConfigurationError {\r\n        return new ClientConfigurationError(\r\n            ClientConfigurationErrorMessage.invalidCodeChallengeMethod.code,\r\n            ClientConfigurationErrorMessage.invalidCodeChallengeMethod.desc\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Throws error when both params: code_challenge and code_challenge_method are not passed together\r\n     */\r\n    static createInvalidCodeChallengeParamsError(): ClientConfigurationError {\r\n        return new ClientConfigurationError(\r\n            ClientConfigurationErrorMessage.invalidCodeChallengeParams.code,\r\n            ClientConfigurationErrorMessage.invalidCodeChallengeParams.desc\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Throws an error when the user passes invalid cloudDiscoveryMetadata\r\n     */\r\n    static createInvalidCloudDiscoveryMetadataError(): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.invalidCloudDiscoveryMetadata.code,\r\n            ClientConfigurationErrorMessage.invalidCloudDiscoveryMetadata.desc);\r\n    }\r\n\r\n    /**\r\n     * Throws an error when the user passes invalid cloudDiscoveryMetadata\r\n     */\r\n    static createInvalidAuthorityMetadataError(): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.invalidAuthorityMetadata.code,\r\n            ClientConfigurationErrorMessage.invalidAuthorityMetadata.desc);\r\n    }\r\n\r\n    /**\r\n     * Throws error when provided authority is not a member of the trusted host list\r\n     */\r\n    static createUntrustedAuthorityError(): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.untrustedAuthority.code,\r\n            ClientConfigurationErrorMessage.untrustedAuthority.desc);\r\n    }\r\n\r\n    /**\r\n     * Throws error when resourceRequestMethod or resourceRequestUri is missing\r\n     */\r\n    static createResourceRequestParametersRequiredError(): ClientConfigurationError {\r\n        return new ClientConfigurationError(ClientConfigurationErrorMessage.resourceRequestParametersRequired.code,\r\n            ClientConfigurationErrorMessage.resourceRequestParametersRequired.desc);\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { ClientConfigurationError } from \"../error/ClientConfigurationError\";\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\nimport { OIDC_SCOPES } from \"../utils/Constants\";\r\n\r\n/**\r\n * The ScopeSet class creates a set of scopes. Scopes are case-insensitive, unique values, so the Set object in JS makes\r\n * the most sense to implement for this class. All scopes are trimmed and converted to lower case strings in intersection and union functions\r\n * to ensure uniqueness of strings.\r\n */\r\nexport class ScopeSet {\r\n    // Scopes as a Set of strings\r\n    private scopes: Set<string>;\r\n\r\n    constructor(inputScopes: Array<string>) {\r\n        // Filter empty string and null/undefined array items\r\n        const scopeArr = inputScopes ? StringUtils.trimArrayEntries([...inputScopes]) : [];\r\n        const filteredInput = scopeArr ? StringUtils.removeEmptyStringsFromArray(scopeArr) : [];\r\n\r\n        // Validate and filter scopes (validate function throws if validation fails)\r\n        this.validateInputScopes(filteredInput);\r\n\r\n        this.scopes = new Set<string>(); // Iterator in constructor not supported by IE11\r\n        filteredInput.forEach(scope => this.scopes.add(scope));\r\n    }\r\n\r\n    /**\r\n     * Factory method to create ScopeSet from space-delimited string\r\n     * @param inputScopeString\r\n     * @param appClientId\r\n     * @param scopesRequired\r\n     */\r\n    static fromString(inputScopeString: string): ScopeSet {\r\n        inputScopeString = inputScopeString || \"\";\r\n        const inputScopes: Array<string> = inputScopeString.split(\" \");\r\n        return new ScopeSet(inputScopes);\r\n    }\r\n\r\n    /**\r\n     * Used to validate the scopes input parameter requested  by the developer.\r\n     * @param {Array<string>} inputScopes - Developer requested permissions. Not all scopes are guaranteed to be included in the access token returned.\r\n     * @param {boolean} scopesRequired - Boolean indicating whether the scopes array is required or not\r\n     */\r\n    private validateInputScopes(inputScopes: Array<string>): void {\r\n        // Check if scopes are required but not given or is an empty array\r\n        if (!inputScopes || inputScopes.length < 1) {\r\n            throw ClientConfigurationError.createEmptyScopesArrayError(inputScopes);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Check if a given scope is present in this set of scopes.\r\n     * @param scope\r\n     */\r\n    containsScope(scope: string): boolean {\r\n        const lowerCaseScopes = this.printScopesLowerCase().split(\" \");\r\n        const lowerCaseScopesSet = new ScopeSet(lowerCaseScopes);\r\n        // compare lowercase scopes\r\n        return !StringUtils.isEmpty(scope) ? lowerCaseScopesSet.scopes.has(scope.toLowerCase()) : false;\r\n    }\r\n\r\n    /**\r\n     * Check if a set of scopes is present in this set of scopes.\r\n     * @param scopeSet\r\n     */\r\n    containsScopeSet(scopeSet: ScopeSet): boolean {\r\n        if (!scopeSet || scopeSet.scopes.size <= 0) {\r\n            return false;\r\n        }\r\n\r\n        return (this.scopes.size >= scopeSet.scopes.size && scopeSet.asArray().every(scope => this.containsScope(scope)));\r\n    }\r\n\r\n    /**\r\n     * Check if set of scopes contains only the defaults\r\n     */\r\n    containsOnlyOIDCScopes(): boolean {\r\n        let defaultScopeCount = 0;\r\n        OIDC_SCOPES.forEach((defaultScope: string) => {\r\n            if (this.containsScope(defaultScope)) {\r\n                defaultScopeCount += 1;\r\n            }\r\n        });\r\n\r\n        return this.scopes.size === defaultScopeCount;\r\n    }\r\n\r\n    /**\r\n     * Appends single scope if passed\r\n     * @param newScope\r\n     */\r\n    appendScope(newScope: string): void {\r\n        if (!StringUtils.isEmpty(newScope)) {\r\n            this.scopes.add(newScope.trim());\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Appends multiple scopes if passed\r\n     * @param newScopes\r\n     */\r\n    appendScopes(newScopes: Array<string>): void {\r\n        try {\r\n            newScopes.forEach(newScope => this.appendScope(newScope));\r\n        } catch (e) {\r\n            throw ClientAuthError.createAppendScopeSetError(e);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Removes element from set of scopes.\r\n     * @param scope\r\n     */\r\n    removeScope(scope: string): void {\r\n        if (StringUtils.isEmpty(scope)) {\r\n            throw ClientAuthError.createRemoveEmptyScopeFromSetError(scope);\r\n        }\r\n        this.scopes.delete(scope.trim());\r\n    }\r\n\r\n    /**\r\n     * Removes default scopes from set of scopes\r\n     * Primarily used to prevent cache misses if the default scopes are not returned from the server\r\n     */\r\n    removeOIDCScopes(): void {\r\n        OIDC_SCOPES.forEach((defaultScope: string) => {\r\n            this.scopes.delete(defaultScope);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Combines an array of scopes with the current set of scopes.\r\n     * @param otherScopes\r\n     */\r\n    unionScopeSets(otherScopes: ScopeSet): Set<string> {\r\n        if (!otherScopes) {\r\n            throw ClientAuthError.createEmptyInputScopeSetError(otherScopes);\r\n        }\r\n        const unionScopes = new Set<string>(); // Iterator in constructor not supported in IE11\r\n        otherScopes.scopes.forEach(scope => unionScopes.add(scope.toLowerCase()));\r\n        this.scopes.forEach(scope => unionScopes.add(scope.toLowerCase()));\r\n        return unionScopes;\r\n    }\r\n\r\n    /**\r\n     * Check if scopes intersect between this set and another.\r\n     * @param otherScopes\r\n     */\r\n    intersectingScopeSets(otherScopes: ScopeSet): boolean {\r\n        if (!otherScopes) {\r\n            throw ClientAuthError.createEmptyInputScopeSetError(otherScopes);\r\n        }\r\n        \r\n        // Do not allow OIDC scopes to be the only intersecting scopes\r\n        if (!otherScopes.containsOnlyOIDCScopes()) {\r\n            otherScopes.removeOIDCScopes();\r\n        }\r\n        const unionScopes = this.unionScopeSets(otherScopes);\r\n        const sizeOtherScopes = otherScopes.getScopeCount();\r\n        const sizeThisScopes = this.getScopeCount();\r\n        const sizeUnionScopes = unionScopes.size;\r\n        return sizeUnionScopes < (sizeThisScopes + sizeOtherScopes);\r\n    }\r\n\r\n    /**\r\n     * Returns size of set of scopes.\r\n     */\r\n    getScopeCount(): number {\r\n        return this.scopes.size;\r\n    }\r\n\r\n    /**\r\n     * Returns the scopes as an array of string values\r\n     */\r\n    asArray(): Array<string> {\r\n        const array: Array<string> = [];\r\n        this.scopes.forEach(val => array.push(val));\r\n        return array;\r\n    }\r\n\r\n    /**\r\n     * Prints scopes into a space-delimited string\r\n     */\r\n    printScopes(): string {\r\n        if (this.scopes) {\r\n            const scopeArr = this.asArray();\r\n            return scopeArr.join(\" \");\r\n        }\r\n        return \"\";\r\n    }\r\n\r\n    /**\r\n     * Prints scopes into a space-delimited lower-case string (used for caching)\r\n     */\r\n    printScopesLowerCase(): string {\r\n        return this.printScopes().toLowerCase();\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\nimport { ICrypto } from \"../crypto/ICrypto\";\r\n\r\n/**\r\n * Client info object which consists of two IDs. Need to add more info here.\r\n */\r\nexport type ClientInfo = {\r\n    uid: string,\r\n    utid: string\r\n};\r\n\r\n/**\r\n * Function to build a client info object\r\n * @param rawClientInfo\r\n * @param crypto\r\n */\r\nexport function buildClientInfo(rawClientInfo: string, crypto: ICrypto): ClientInfo {\r\n    if (StringUtils.isEmpty(rawClientInfo)) {\r\n        throw ClientAuthError.createClientInfoEmptyError();\r\n    }\r\n\r\n    try {\r\n        const decodedClientInfo: string = crypto.base64Decode(rawClientInfo);\r\n        return JSON.parse(decodedClientInfo) as ClientInfo;\r\n    } catch (e) {\r\n        throw ClientAuthError.createClientInfoDecodingError(e);\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\n/**\r\n * Authority types supported by MSAL.\r\n */\r\nexport enum AuthorityType {\r\n    Default,\r\n    Adfs\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport {\r\n    Separators,\r\n    CacheAccountType,\r\n    CacheType,\r\n    Constants,\r\n} from \"../../utils/Constants\";\r\nimport { Authority } from \"../../authority/Authority\";\r\nimport { AuthToken } from \"../../account/AuthToken\";\r\nimport { ICrypto } from \"../../crypto/ICrypto\";\r\nimport { buildClientInfo } from \"../../account/ClientInfo\";\r\nimport { StringUtils } from \"../../utils/StringUtils\";\r\nimport { AccountInfo } from \"../../account/AccountInfo\";\r\nimport { ClientAuthError } from \"../../error/ClientAuthError\";\r\nimport { AuthorityType } from \"../../authority/AuthorityType\";\r\nimport { Logger } from \"../../logger/Logger\";\r\nimport { TokenClaims } from \"../../account/TokenClaims\";\r\n\r\n/**\r\n * Type that defines required and optional parameters for an Account field (based on universal cache schema implemented by all MSALs).\r\n *\r\n * Key : Value Schema\r\n *\r\n * Key: <home_account_id>-<environment>-<realm*>\r\n *\r\n * Value Schema:\r\n * {\r\n *      homeAccountId: home account identifier for the auth scheme,\r\n *      environment: entity that issued the token, represented as a full host\r\n *      realm: Full tenant or organizational identifier that the account belongs to\r\n *      localAccountId: Original tenant-specific accountID, usually used for legacy cases\r\n *      username: primary username that represents the user, usually corresponds to preferred_username in the v2 endpt\r\n *      authorityType: Accounts authority type as a string\r\n *      name: Full name for the account, including given name and family name,\r\n *      clientInfo: Full base64 encoded client info received from ESTS\r\n *      lastModificationTime: last time this entity was modified in the cache\r\n *      lastModificationApp:\r\n *      oboAssertion: access token passed in as part of OBO request\r\n *      idTokenClaims: Object containing claims parsed from ID token\r\n * }\r\n */\r\nexport class AccountEntity {\r\n    homeAccountId: string;\r\n    environment: string;\r\n    realm: string;\r\n    localAccountId: string;\r\n    username: string;\r\n    authorityType: string;\r\n    name?: string;\r\n    clientInfo?: string;\r\n    lastModificationTime?: string;\r\n    lastModificationApp?: string;\r\n    oboAssertion?: string;\r\n    cloudGraphHostName?: string;\r\n    msGraphHost?: string; \r\n    idTokenClaims?: TokenClaims;\r\n\r\n    /**\r\n     * Generate Account Id key component as per the schema: <home_account_id>-<environment>\r\n     */\r\n    generateAccountId(): string {\r\n        const accountId: Array<string> = [this.homeAccountId, this.environment];\r\n        return accountId.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();\r\n    }\r\n\r\n    /**\r\n     * Generate Account Cache Key as per the schema: <home_account_id>-<environment>-<realm*>\r\n     */\r\n    generateAccountKey(): string {\r\n        return AccountEntity.generateAccountCacheKey({\r\n            homeAccountId: this.homeAccountId,\r\n            environment: this.environment,\r\n            tenantId: this.realm,\r\n            username: this.username,\r\n            localAccountId: this.localAccountId\r\n        });\r\n    }\r\n\r\n    /**\r\n     * returns the type of the cache (in this case account)\r\n     */\r\n    generateType(): number {\r\n        switch (this.authorityType) {\r\n            case CacheAccountType.ADFS_ACCOUNT_TYPE:\r\n                return CacheType.ADFS;\r\n            case CacheAccountType.MSAV1_ACCOUNT_TYPE:\r\n                return CacheType.MSA;\r\n            case CacheAccountType.MSSTS_ACCOUNT_TYPE:\r\n                return CacheType.MSSTS;\r\n            case CacheAccountType.GENERIC_ACCOUNT_TYPE:\r\n                return CacheType.GENERIC;\r\n            default: {\r\n                throw ClientAuthError.createUnexpectedAccountTypeError();\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns the AccountInfo interface for this account.\r\n     */\r\n    getAccountInfo(): AccountInfo {\r\n        return {\r\n            homeAccountId: this.homeAccountId,\r\n            environment: this.environment,\r\n            tenantId: this.realm,\r\n            username: this.username,\r\n            localAccountId: this.localAccountId,\r\n            name: this.name,\r\n            idTokenClaims: this.idTokenClaims\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Generates account key from interface\r\n     * @param accountInterface\r\n     */\r\n    static generateAccountCacheKey(accountInterface: AccountInfo): string {\r\n        const accountKey = [\r\n            accountInterface.homeAccountId,\r\n            accountInterface.environment || \"\",\r\n            accountInterface.tenantId || \"\",\r\n        ];\r\n\r\n        return accountKey.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();\r\n    }\r\n\r\n    /**\r\n     * Build Account cache from IdToken, clientInfo and authority/policy. Associated with AAD.\r\n     * @param clientInfo\r\n     * @param authority\r\n     * @param idToken\r\n     * @param policy\r\n     */\r\n    static createAccount(\r\n        clientInfo: string,\r\n        homeAccountId: string,\r\n        authority: Authority,\r\n        idToken: AuthToken,\r\n        oboAssertion?: string,\r\n        cloudGraphHostName?: string,\r\n        msGraphHost?: string\r\n    ): AccountEntity {\r\n        const account: AccountEntity = new AccountEntity();\r\n\r\n        account.authorityType = CacheAccountType.MSSTS_ACCOUNT_TYPE;\r\n        account.clientInfo = clientInfo;\r\n        account.homeAccountId = homeAccountId;\r\n\r\n        const env = authority.getPreferredCache();\r\n        if (StringUtils.isEmpty(env)) {\r\n            throw ClientAuthError.createInvalidCacheEnvironmentError();\r\n        }\r\n\r\n        account.environment = env;\r\n        // non AAD scenarios can have empty realm\r\n        account.realm = idToken?.claims?.tid || \"\";\r\n        account.oboAssertion = oboAssertion;\r\n        \r\n        if (idToken) {\r\n            account.idTokenClaims = idToken.claims;\r\n\r\n            // How do you account for MSA CID here?\r\n            account.localAccountId = idToken?.claims?.oid || idToken?.claims?.sub || \"\";\r\n\r\n            /*\r\n             * In B2C scenarios the emails claim is used instead of preferred_username and it is an array. In most cases it will contain a single email.\r\n             * This field should not be relied upon if a custom policy is configured to return more than 1 email.\r\n             */\r\n            account.username = idToken?.claims?.preferred_username || (idToken?.claims?.emails? idToken.claims.emails[0]: \"\");\r\n            account.name = idToken?.claims?.name;\r\n        }\r\n\r\n        account.cloudGraphHostName = cloudGraphHostName;\r\n        account.msGraphHost = msGraphHost;\r\n\r\n        return account;\r\n    }\r\n\r\n    /**\r\n     * Builds non-AAD/ADFS account.\r\n     * @param authority\r\n     * @param idToken\r\n     */\r\n    static createGenericAccount(\r\n        authority: Authority,\r\n        homeAccountId: string,\r\n        idToken: AuthToken,\r\n        oboAssertion?: string,\r\n        cloudGraphHostName?: string,\r\n        msGraphHost?: string\r\n    ): AccountEntity {\r\n        const account: AccountEntity = new AccountEntity();\r\n\r\n        account.authorityType = (authority.authorityType === AuthorityType.Adfs) ? CacheAccountType.ADFS_ACCOUNT_TYPE : CacheAccountType.GENERIC_ACCOUNT_TYPE;\r\n        account.homeAccountId = homeAccountId;\r\n        // non AAD scenarios can have empty realm\r\n        account.realm = \"\";\r\n        account.oboAssertion = oboAssertion;\r\n\r\n        const env = authority.getPreferredCache();\r\n\r\n        if (StringUtils.isEmpty(env)) {\r\n            throw ClientAuthError.createInvalidCacheEnvironmentError();\r\n        }\r\n\r\n        if (idToken) {\r\n            // How do you account for MSA CID here?\r\n            account.localAccountId = idToken?.claims?.oid || idToken?.claims?.sub || \"\";\r\n            // upn claim for most ADFS scenarios\r\n            account.username = idToken?.claims?.upn || \"\";\r\n            account.name = idToken?.claims?.name || \"\";\r\n            account.idTokenClaims = idToken?.claims;\r\n        }\r\n\r\n        account.environment = env;\r\n\r\n        account.cloudGraphHostName = cloudGraphHostName;\r\n        account.msGraphHost = msGraphHost;\r\n\r\n        /*\r\n         * add uniqueName to claims\r\n         * account.name = idToken.claims.uniqueName;\r\n         */\r\n\r\n        return account;\r\n    }\r\n\r\n    /**\r\n     * Generate HomeAccountId from server response\r\n     * @param serverClientInfo\r\n     * @param authType\r\n     */\r\n    static generateHomeAccountId(serverClientInfo: string, authType: AuthorityType, logger: Logger, cryptoObj: ICrypto, idToken?: AuthToken): string {\r\n\r\n        const accountId = idToken?.claims?.sub ? idToken.claims.sub : Constants.EMPTY_STRING;\r\n\r\n        // since ADFS does not have tid and does not set client_info\r\n        if (authType === AuthorityType.Adfs) {\r\n            return accountId;\r\n        }\r\n\r\n        // for cases where there is clientInfo\r\n        if (serverClientInfo) {\r\n            const clientInfo = buildClientInfo(serverClientInfo, cryptoObj);\r\n            if (!StringUtils.isEmpty(clientInfo.uid) && !StringUtils.isEmpty(clientInfo.utid)) {\r\n                return `${clientInfo.uid}${Separators.CLIENT_INFO_SEPARATOR}${clientInfo.utid}`;\r\n            }\r\n        }\r\n\r\n        // default to \"sub\" claim\r\n        logger.verbose(\"No client info in response\");\r\n        return accountId;\r\n    }\r\n\r\n    /**\r\n     * Validates an entity: checks for all expected params\r\n     * @param entity\r\n     */\r\n    static isAccountEntity(entity: object): boolean {\r\n\r\n        if (!entity) {\r\n            return false;\r\n        }\r\n\r\n        return (\r\n            entity.hasOwnProperty(\"homeAccountId\") &&\r\n            entity.hasOwnProperty(\"environment\") &&\r\n            entity.hasOwnProperty(\"realm\") &&\r\n            entity.hasOwnProperty(\"localAccountId\") &&\r\n            entity.hasOwnProperty(\"username\") &&\r\n            entity.hasOwnProperty(\"authorityType\")\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Helper function to determine whether 2 accounts are equal\r\n     * Used to avoid unnecessary state updates\r\n     * @param arrayA \r\n     * @param arrayB \r\n     */\r\n    static accountInfoIsEqual(accountA: AccountInfo | null, accountB: AccountInfo | null): boolean {\r\n        if (!accountA || !accountB) {\r\n            return false;\r\n        }\r\n        return (accountA.homeAccountId === accountB.homeAccountId) && \r\n            (accountA.localAccountId === accountB.localAccountId) &&\r\n            (accountA.username === accountB.username) &&\r\n            (accountA.tenantId === accountB.tenantId) &&\r\n            (accountA.environment === accountB.environment);\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { TokenClaims } from \"./TokenClaims\";\r\nimport { DecodedAuthToken } from \"./DecodedAuthToken\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\nimport { ICrypto } from \"../crypto/ICrypto\";\r\n\r\n/**\r\n * JWT Token representation class. Parses token string and generates claims object.\r\n */\r\nexport class AuthToken {\r\n\r\n    // Raw Token string\r\n    rawToken: string;\r\n    // Claims inside token\r\n    claims: TokenClaims;\r\n    constructor(rawToken: string, crypto: ICrypto) {\r\n        if (StringUtils.isEmpty(rawToken)) {\r\n            throw ClientAuthError.createTokenNullOrEmptyError(rawToken);\r\n        }\r\n\r\n        this.rawToken = rawToken;\r\n        this.claims = AuthToken.extractTokenClaims(rawToken, crypto);\r\n    }\r\n\r\n    /**\r\n     * Extract token by decoding the rawToken\r\n     *\r\n     * @param encodedToken\r\n     */\r\n    static extractTokenClaims(encodedToken: string, crypto: ICrypto): TokenClaims {\r\n\r\n        const decodedToken: DecodedAuthToken = StringUtils.decodeAuthToken(encodedToken);\r\n\r\n        // token will be decoded to get the username\r\n        try {\r\n            const base64TokenPayload = decodedToken.JWSPayload;\r\n\r\n            // base64Decode() should throw an error if there is an issue\r\n            const base64Decoded = crypto.base64Decode(base64TokenPayload);\r\n            return JSON.parse(base64Decoded) as TokenClaims;\r\n        } catch (err) {\r\n            throw ClientAuthError.createTokenParsingError(err);\r\n        }\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { AccountCache, AccountFilter, CredentialFilter, CredentialCache, ValidCredentialType, AppMetadataFilter, AppMetadataCache } from \"./utils/CacheTypes\";\r\nimport { CacheRecord } from \"./entities/CacheRecord\";\r\nimport { CacheSchemaType, CredentialType, Constants, APP_METADATA, THE_FAMILY_ID, AUTHORITY_METADATA_CONSTANTS } from \"../utils/Constants\";\r\nimport { CredentialEntity } from \"./entities/CredentialEntity\";\r\nimport { ScopeSet } from \"../request/ScopeSet\";\r\nimport { AccountEntity } from \"./entities/AccountEntity\";\r\nimport { AccessTokenEntity } from \"./entities/AccessTokenEntity\";\r\nimport { IdTokenEntity } from \"./entities/IdTokenEntity\";\r\nimport { RefreshTokenEntity } from \"./entities/RefreshTokenEntity\";\r\nimport { AuthError } from \"../error/AuthError\";\r\nimport { ICacheManager } from \"./interface/ICacheManager\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\nimport { AccountInfo } from \"../account/AccountInfo\";\r\nimport { AppMetadataEntity } from \"./entities/AppMetadataEntity\";\r\nimport { ServerTelemetryEntity } from \"./entities/ServerTelemetryEntity\";\r\nimport { ThrottlingEntity } from \"./entities/ThrottlingEntity\";\r\nimport { AuthToken } from \"../account/AuthToken\";\r\nimport { ICrypto } from \"../crypto/ICrypto\";\r\nimport { AuthorityMetadataEntity } from \"./entities/AuthorityMetadataEntity\";\r\n\r\n/**\r\n * Interface class which implement cache storage functions used by MSAL to perform validity checks, and store tokens.\r\n */\r\nexport abstract class CacheManager implements ICacheManager {\r\n    protected clientId: string;\r\n    protected cryptoImpl: ICrypto;\r\n\r\n    constructor(clientId: string, cryptoImpl: ICrypto) {\r\n        this.clientId = clientId;\r\n        this.cryptoImpl = cryptoImpl;\r\n    }\r\n\r\n    /**\r\n     * fetch the account entity from the platform cache\r\n     *  @param accountKey\r\n     */\r\n    abstract getAccount(accountKey: string): AccountEntity | null;\r\n\r\n    /**\r\n     * set account entity in the platform cache\r\n     * @param account\r\n     */\r\n    abstract setAccount(account: AccountEntity): void;\r\n\r\n    /**\r\n     * fetch the idToken entity from the platform cache\r\n     * @param idTokenKey\r\n     */\r\n    abstract getIdTokenCredential(idTokenKey: string): IdTokenEntity | null;\r\n\r\n    /**\r\n     * set idToken entity to the platform cache\r\n     * @param idToken\r\n     */\r\n    abstract setIdTokenCredential(idToken: IdTokenEntity): void;\r\n\r\n    /**\r\n     * fetch the idToken entity from the platform cache\r\n     * @param accessTokenKey\r\n     */\r\n    abstract getAccessTokenCredential(accessTokenKey: string): AccessTokenEntity | null;\r\n\r\n    /**\r\n     * set idToken entity to the platform cache\r\n     * @param accessToken\r\n     */\r\n    abstract setAccessTokenCredential(accessToken: AccessTokenEntity): void;\r\n\r\n    /**\r\n     * fetch the idToken entity from the platform cache\r\n     * @param refreshTokenKey\r\n     */\r\n    abstract getRefreshTokenCredential(refreshTokenKey: string): RefreshTokenEntity | null;\r\n\r\n    /**\r\n     * set idToken entity to the platform cache\r\n     * @param refreshToken\r\n     */\r\n    abstract setRefreshTokenCredential(refreshToken: RefreshTokenEntity): void;\r\n\r\n    /**\r\n     * fetch appMetadata entity from the platform cache\r\n     * @param appMetadataKey\r\n     */\r\n    abstract getAppMetadata(appMetadataKey: string): AppMetadataEntity | null;\r\n\r\n    /**\r\n     * set appMetadata entity to the platform cache\r\n     * @param appMetadata\r\n     */\r\n    abstract setAppMetadata(appMetadata: AppMetadataEntity): void;\r\n\r\n    /**\r\n     * fetch server telemetry entity from the platform cache\r\n     * @param serverTelemetryKey\r\n     */\r\n    abstract getServerTelemetry(serverTelemetryKey: string): ServerTelemetryEntity | null;\r\n\r\n    /**\r\n     * set server telemetry entity to the platform cache\r\n     * @param serverTelemetryKey\r\n     * @param serverTelemetry\r\n     */\r\n    abstract setServerTelemetry(serverTelemetryKey: string, serverTelemetry: ServerTelemetryEntity): void;\r\n\r\n    /**\r\n     * fetch cloud discovery metadata entity from the platform cache\r\n     * @param key\r\n     */\r\n    abstract getAuthorityMetadata(key: string): AuthorityMetadataEntity | null;\r\n\r\n    /**\r\n     * \r\n     */\r\n    abstract getAuthorityMetadataKeys(): Array<string>;\r\n\r\n    /**\r\n     * set cloud discovery metadata entity to the platform cache\r\n     * @param key\r\n     * @param value\r\n     */\r\n    abstract setAuthorityMetadata(key: string, value: AuthorityMetadataEntity): void;\r\n\r\n    /**\r\n     * fetch throttling entity from the platform cache\r\n     * @param throttlingCacheKey\r\n     */\r\n    abstract getThrottlingCache(throttlingCacheKey: string): ThrottlingEntity | null;\r\n\r\n    /**\r\n     * set throttling entity to the platform cache\r\n     * @param throttlingCacheKey\r\n     * @param throttlingCache\r\n     */\r\n    abstract setThrottlingCache(throttlingCacheKey: string, throttlingCache: ThrottlingEntity): void;;\r\n\r\n    /**\r\n     * Function to remove an item from cache given its key.\r\n     * @param key\r\n     */\r\n    abstract removeItem(key: string, type?: string): boolean;\r\n\r\n    /**\r\n     * Function which returns boolean whether cache contains a specific key.\r\n     * @param key\r\n     */\r\n    abstract containsKey(key: string, type?: string): boolean;\r\n\r\n    /**\r\n     * Function which retrieves all current keys from the cache.\r\n     */\r\n    abstract getKeys(): string[];\r\n\r\n    /**\r\n     * Function which clears cache.\r\n     */\r\n    abstract clear(): void;\r\n\r\n    /**\r\n     * Returns all accounts in cache\r\n     */\r\n    getAllAccounts(): AccountInfo[] {\r\n        const currentAccounts: AccountCache = this.getAccountsFilteredBy();\r\n        const accountValues: AccountEntity[] = Object.keys(currentAccounts).map(accountKey => currentAccounts[accountKey]);\r\n        const numAccounts = accountValues.length;\r\n        if (numAccounts < 1) {\r\n            return [];\r\n        } else {\r\n            const allAccounts = accountValues.map<AccountInfo>((value) => {\r\n                const accountEntity = CacheManager.toObject<AccountEntity>(new AccountEntity(), value);\r\n                const accountInfo = accountEntity.getAccountInfo();\r\n                const idToken = this.readIdTokenFromCache(this.clientId, accountInfo);\r\n                if (idToken && !accountInfo.idTokenClaims) {\r\n                    accountInfo.idTokenClaims = new AuthToken(idToken.secret, this.cryptoImpl).claims;\r\n                }\r\n\r\n                return accountInfo;\r\n                \r\n            });\r\n            return allAccounts;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * saves a cache record\r\n     * @param cacheRecord\r\n     */\r\n    saveCacheRecord(cacheRecord: CacheRecord): void {\r\n        if (!cacheRecord) {\r\n            throw ClientAuthError.createNullOrUndefinedCacheRecord();\r\n        }\r\n\r\n        if (!!cacheRecord.account) {\r\n            this.setAccount(cacheRecord.account);\r\n        }\r\n\r\n        if (!!cacheRecord.idToken) {\r\n            this.setIdTokenCredential(cacheRecord.idToken);\r\n        }\r\n\r\n        if (!!cacheRecord.accessToken) {\r\n            this.saveAccessToken(cacheRecord.accessToken);\r\n        }\r\n\r\n        if (!!cacheRecord.refreshToken) {\r\n            this.setRefreshTokenCredential(cacheRecord.refreshToken);\r\n        }\r\n\r\n        if (!!cacheRecord.appMetadata) {\r\n            this.setAppMetadata(cacheRecord.appMetadata);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * saves access token credential\r\n     * @param credential\r\n     */\r\n    private saveAccessToken(credential: AccessTokenEntity): void {\r\n        const currentTokenCache = this.getCredentialsFilteredBy({\r\n            clientId: credential.clientId,\r\n            credentialType: CredentialType.ACCESS_TOKEN,\r\n            environment: credential.environment,\r\n            homeAccountId: credential.homeAccountId,\r\n            realm: credential.realm,\r\n        });\r\n        const currentScopes = ScopeSet.fromString(credential.target);\r\n        const currentAccessTokens: AccessTokenEntity[] = Object.keys(currentTokenCache.accessTokens).map(key => currentTokenCache.accessTokens[key]);\r\n        if (currentAccessTokens) {\r\n            currentAccessTokens.forEach((tokenEntity) => {\r\n                const tokenScopeSet = ScopeSet.fromString(tokenEntity.target);\r\n                if (tokenScopeSet.intersectingScopeSets(currentScopes)) {\r\n                    this.removeCredential(tokenEntity);\r\n                }\r\n            });\r\n        }\r\n        this.setAccessTokenCredential(credential);\r\n    }\r\n\r\n    /**\r\n     * retrieve accounts matching all provided filters; if no filter is set, get all accounts\r\n     * not checking for casing as keys are all generated in lower case, remember to convert to lower case if object properties are compared\r\n     * @param homeAccountId\r\n     * @param environment\r\n     * @param realm\r\n     */\r\n    getAccountsFilteredBy(accountFilter?: AccountFilter): AccountCache {\r\n        return this.getAccountsFilteredByInternal(\r\n            accountFilter ? accountFilter.homeAccountId : \"\",\r\n            accountFilter ? accountFilter.environment : \"\",\r\n            accountFilter ? accountFilter.realm : \"\"\r\n        );\r\n    }\r\n\r\n    /**\r\n     * retrieve accounts matching all provided filters; if no filter is set, get all accounts\r\n     * not checking for casing as keys are all generated in lower case, remember to convert to lower case if object properties are compared\r\n     * @param homeAccountId\r\n     * @param environment\r\n     * @param realm\r\n     */\r\n    private getAccountsFilteredByInternal(\r\n        homeAccountId?: string,\r\n        environment?: string,\r\n        realm?: string\r\n    ): AccountCache {\r\n        const allCacheKeys = this.getKeys();\r\n        const matchingAccounts: AccountCache = {};\r\n\r\n        allCacheKeys.forEach((cacheKey) => {\r\n            const entity: AccountEntity | null = this.getAccount(cacheKey);\r\n\r\n            if (!entity) {\r\n                return;\r\n            }\r\n\r\n            if (!!homeAccountId && !this.matchHomeAccountId(entity, homeAccountId)) {\r\n                return;\r\n            }\r\n\r\n            if (!!environment && !this.matchEnvironment(entity, environment)) {\r\n                return;\r\n            }\r\n\r\n            if (!!realm && !this.matchRealm(entity, realm)) {\r\n                return;\r\n            }\r\n\r\n            matchingAccounts[cacheKey] = entity;\r\n        });\r\n\r\n        return matchingAccounts;\r\n    }\r\n\r\n    /**\r\n     * retrieve credentails matching all provided filters; if no filter is set, get all credentials\r\n     * @param homeAccountId\r\n     * @param environment\r\n     * @param credentialType\r\n     * @param clientId\r\n     * @param realm\r\n     * @param target\r\n     */\r\n    getCredentialsFilteredBy(filter: CredentialFilter): CredentialCache {\r\n        return this.getCredentialsFilteredByInternal(\r\n            filter.homeAccountId,\r\n            filter.environment,\r\n            filter.credentialType,\r\n            filter.clientId,\r\n            filter.familyId,\r\n            filter.realm,\r\n            filter.target,\r\n            filter.oboAssertion\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Support function to help match credentials\r\n     * @param homeAccountId\r\n     * @param environment\r\n     * @param credentialType\r\n     * @param clientId\r\n     * @param realm\r\n     * @param target\r\n     */\r\n    private getCredentialsFilteredByInternal(\r\n        homeAccountId?: string,\r\n        environment?: string,\r\n        credentialType?: string,\r\n        clientId?: string,\r\n        familyId?: string,\r\n        realm?: string,\r\n        target?: string,\r\n        oboAssertion?: string\r\n    ): CredentialCache {\r\n        const allCacheKeys = this.getKeys();\r\n        const matchingCredentials: CredentialCache = {\r\n            idTokens: {},\r\n            accessTokens: {},\r\n            refreshTokens: {},\r\n        };\r\n\r\n        allCacheKeys.forEach((cacheKey) => {\r\n            // don't parse any non-credential type cache entities\r\n            const credType = CredentialEntity.getCredentialType(cacheKey);\r\n            if (credType === Constants.NOT_DEFINED) {\r\n                return;\r\n            }\r\n\r\n            // Attempt retrieval\r\n            const entity = this.getSpecificCredential(cacheKey, credType);\r\n            if (!entity) {\r\n                return;\r\n            }\r\n\r\n            if (!!oboAssertion && !this.matchOboAssertion(entity, oboAssertion)) {\r\n                return;\r\n            }\r\n\r\n            if (!!homeAccountId && !this.matchHomeAccountId(entity, homeAccountId)) {\r\n                return;\r\n            }\r\n\r\n            if (!!environment && !this.matchEnvironment(entity, environment)) {\r\n                return;\r\n            }\r\n\r\n            if (!!realm && !this.matchRealm(entity, realm)) {\r\n                return;\r\n            }\r\n\r\n            if (!!credentialType && !this.matchCredentialType(entity, credentialType)) {\r\n                return;\r\n            }\r\n\r\n            if (!!clientId && !this.matchClientId(entity, clientId)) {\r\n                return;\r\n            }\r\n\r\n            if (!!familyId && !this.matchFamilyId(entity, familyId)) {\r\n                return;\r\n            }\r\n\r\n            /*\r\n             * idTokens do not have \"target\", target specific refreshTokens do exist for some types of authentication\r\n             * Resource specific refresh tokens case will be added when the support is deemed necessary\r\n             */\r\n            if (!!target && !this.matchTarget(entity, target)) {\r\n                return;\r\n            }\r\n\r\n            switch (credType) {\r\n                case CredentialType.ID_TOKEN:\r\n                    matchingCredentials.idTokens[cacheKey] = entity as IdTokenEntity;\r\n                    break;\r\n                case CredentialType.ACCESS_TOKEN:\r\n                    matchingCredentials.accessTokens[cacheKey] = entity as AccessTokenEntity;\r\n                    break;\r\n                case CredentialType.REFRESH_TOKEN:\r\n                    matchingCredentials.refreshTokens[cacheKey] = entity as RefreshTokenEntity;\r\n                    break;\r\n            }\r\n        });\r\n\r\n        return matchingCredentials;\r\n    }\r\n\r\n    /**\r\n     * retrieve appMetadata matching all provided filters; if no filter is set, get all appMetadata\r\n     * @param filter\r\n     */\r\n    getAppMetadataFilteredBy(filter: AppMetadataFilter): AppMetadataCache {\r\n        return this.getAppMetadataFilteredByInternal(\r\n            filter.environment,\r\n            filter.clientId,\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Support function to help match appMetadata\r\n     * @param environment\r\n     * @param clientId\r\n     */\r\n    private getAppMetadataFilteredByInternal(\r\n        environment?: string,\r\n        clientId?: string\r\n    ): AppMetadataCache {\r\n\r\n        const allCacheKeys = this.getKeys();\r\n        const matchingAppMetadata: AppMetadataCache = {};\r\n\r\n        allCacheKeys.forEach((cacheKey) => {\r\n            // don't parse any non-appMetadata type cache entities\r\n            if (!this.isAppMetadata(cacheKey)) {\r\n                return;\r\n            }\r\n\r\n            // Attempt retrieval\r\n            const entity = this.getAppMetadata(cacheKey);\r\n\r\n            if (!entity) {\r\n                return;\r\n            }\r\n\r\n            if (!!environment && !this.matchEnvironment(entity, environment)) {\r\n                return;\r\n            }\r\n\r\n            if (!!clientId && !this.matchClientId(entity, clientId)) {\r\n                return;\r\n            }\r\n\r\n            matchingAppMetadata[cacheKey] = entity;\r\n\r\n        });\r\n\r\n        return matchingAppMetadata;\r\n    }\r\n\r\n    /**\r\n     * retrieve authorityMetadata that contains a matching alias\r\n     * @param filter\r\n     */\r\n    getAuthorityMetadataByAlias(host: string): AuthorityMetadataEntity | null {\r\n        const allCacheKeys = this.getAuthorityMetadataKeys();\r\n        let matchedEntity = null;\r\n\r\n        allCacheKeys.forEach((cacheKey) => {\r\n            // don't parse any non-authorityMetadata type cache entities\r\n            if (!this.isAuthorityMetadata(cacheKey) || cacheKey.indexOf(this.clientId) === -1) {\r\n                return;\r\n            }\r\n\r\n            // Attempt retrieval\r\n            const entity = this.getAuthorityMetadata(cacheKey);\r\n\r\n            if (!entity) {\r\n                return;\r\n            }\r\n\r\n            if (entity.aliases.indexOf(host) === -1) {\r\n                return;\r\n            }\r\n\r\n            matchedEntity = entity;\r\n\r\n        });\r\n        \r\n        return matchedEntity;\r\n    }\r\n\r\n    /**\r\n     * Removes all accounts and related tokens from cache.\r\n     */\r\n    removeAllAccounts(): boolean {\r\n        const allCacheKeys = this.getKeys();\r\n        allCacheKeys.forEach((cacheKey) => {\r\n            const entity = this.getAccount(cacheKey);\r\n            if (!entity) {\r\n                return;\r\n            }\r\n            this.removeAccount(cacheKey);\r\n        });\r\n\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * returns a boolean if the given account is removed\r\n     * @param account\r\n     */\r\n    removeAccount(accountKey: string): boolean {\r\n        const account = this.getAccount(accountKey);\r\n        if (!account) {\r\n            throw ClientAuthError.createNoAccountFoundError();\r\n        }\r\n        return (this.removeAccountContext(account) && this.removeItem(accountKey, CacheSchemaType.ACCOUNT));\r\n    }\r\n\r\n    /**\r\n     * returns a boolean if the given account is removed\r\n     * @param account\r\n     */\r\n    removeAccountContext(account: AccountEntity): boolean {\r\n        const allCacheKeys = this.getKeys();\r\n        const accountId = account.generateAccountId();\r\n\r\n        allCacheKeys.forEach((cacheKey) => {\r\n            // don't parse any non-credential type cache entities\r\n            const credType = CredentialEntity.getCredentialType(cacheKey);\r\n            if (credType === Constants.NOT_DEFINED) {\r\n                return;\r\n            }\r\n\r\n            const cacheEntity = this.getSpecificCredential(cacheKey, credType);\r\n            if (!!cacheEntity && accountId === cacheEntity.generateAccountId()) {\r\n                this.removeCredential(cacheEntity);\r\n            }\r\n        });\r\n\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * returns a boolean if the given credential is removed\r\n     * @param credential\r\n     */\r\n    removeCredential(credential: CredentialEntity): boolean {\r\n        const key = credential.generateCredentialKey();\r\n        return this.removeItem(key, CacheSchemaType.CREDENTIAL);\r\n    }\r\n\r\n    /**\r\n     * Removes all app metadata objects from cache.\r\n     */\r\n    removeAppMetadata(): boolean {\r\n        const allCacheKeys = this.getKeys();\r\n        allCacheKeys.forEach((cacheKey) => {\r\n            if (this.isAppMetadata(cacheKey)) {\r\n                this.removeItem(cacheKey, CacheSchemaType.APP_METADATA);\r\n            }\r\n        });\r\n\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * Retrieve the cached credentials into a cacherecord\r\n     * @param account\r\n     * @param clientId\r\n     * @param scopes\r\n     * @param environment\r\n     */\r\n    readCacheRecord(account: AccountInfo, clientId: string, scopes: ScopeSet, environment: string): CacheRecord {\r\n        const cachedAccount = this.readAccountFromCache(account);\r\n        const cachedIdToken = this.readIdTokenFromCache(clientId, account);\r\n        const cachedAccessToken = this.readAccessTokenFromCache(clientId, account, scopes);\r\n        const cachedRefreshToken = this.readRefreshTokenFromCache(clientId, account, false);\r\n        const cachedAppMetadata = this.readAppMetadataFromCache(environment, clientId);\r\n\r\n        if (cachedAccount && cachedIdToken) {\r\n            cachedAccount.idTokenClaims = new AuthToken(cachedIdToken.secret, this.cryptoImpl).claims;\r\n        }\r\n\r\n        return {\r\n            account: cachedAccount,\r\n            idToken: cachedIdToken,\r\n            accessToken: cachedAccessToken,\r\n            refreshToken: cachedRefreshToken,\r\n            appMetadata: cachedAppMetadata,\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Retrieve AccountEntity from cache\r\n     * @param account\r\n     */\r\n    readAccountFromCache(account: AccountInfo): AccountEntity | null {\r\n        const accountKey: string = AccountEntity.generateAccountCacheKey(account);\r\n        return this.getAccount(accountKey);\r\n    }\r\n\r\n    /**\r\n     * Retrieve IdTokenEntity from cache\r\n     * @param clientId\r\n     * @param account\r\n     * @param inputRealm\r\n     */\r\n    readIdTokenFromCache(clientId: string, account: AccountInfo): IdTokenEntity | null {\r\n        const idTokenFilter: CredentialFilter = {\r\n            homeAccountId: account.homeAccountId,\r\n            environment: account.environment,\r\n            credentialType: CredentialType.ID_TOKEN,\r\n            clientId: clientId,\r\n            realm: account.tenantId,\r\n        };\r\n\r\n        const credentialCache: CredentialCache = this.getCredentialsFilteredBy(idTokenFilter);\r\n        const idTokens = Object.keys(credentialCache.idTokens).map((key) => credentialCache.idTokens[key]);\r\n        const numIdTokens = idTokens.length;\r\n\r\n        if (numIdTokens < 1) {\r\n            return null;\r\n        } else if (numIdTokens > 1) {\r\n            throw ClientAuthError.createMultipleMatchingTokensInCacheError();\r\n        }\r\n\r\n        return idTokens[0] as IdTokenEntity;\r\n    }\r\n\r\n    /**\r\n     * Retrieve AccessTokenEntity from cache\r\n     * @param clientId\r\n     * @param account\r\n     * @param scopes\r\n     * @param inputRealm\r\n     */\r\n    readAccessTokenFromCache(clientId: string, account: AccountInfo, scopes: ScopeSet): AccessTokenEntity | null {\r\n        const accessTokenFilter: CredentialFilter = {\r\n            homeAccountId: account.homeAccountId,\r\n            environment: account.environment,\r\n            credentialType: CredentialType.ACCESS_TOKEN,\r\n            clientId,\r\n            realm: account.tenantId,\r\n            target: scopes.printScopesLowerCase(),\r\n        };\r\n\r\n        const credentialCache: CredentialCache = this.getCredentialsFilteredBy(accessTokenFilter);\r\n        const accessTokens = Object.keys(credentialCache.accessTokens).map((key) => credentialCache.accessTokens[key]);\r\n\r\n        const numAccessTokens = accessTokens.length;\r\n        if (numAccessTokens < 1) {\r\n            return null;\r\n        } else if (numAccessTokens > 1) {\r\n            throw ClientAuthError.createMultipleMatchingTokensInCacheError();\r\n        }\r\n\r\n        return accessTokens[0] as AccessTokenEntity;\r\n    }\r\n\r\n    /**\r\n     * Helper to retrieve the appropriate refresh token from cache\r\n     * @param clientId\r\n     * @param account\r\n     * @param familyRT\r\n     */\r\n    readRefreshTokenFromCache(clientId: string, account: AccountInfo, familyRT: boolean): RefreshTokenEntity | null {\r\n        const id = familyRT ? THE_FAMILY_ID : undefined;\r\n        const refreshTokenFilter: CredentialFilter = {\r\n            homeAccountId: account.homeAccountId,\r\n            environment: account.environment,\r\n            credentialType: CredentialType.REFRESH_TOKEN,\r\n            clientId: clientId,\r\n            familyId: id\r\n        };\r\n\r\n        const credentialCache: CredentialCache = this.getCredentialsFilteredBy(refreshTokenFilter);\r\n        const refreshTokens = Object.keys(credentialCache.refreshTokens).map((key) => credentialCache.refreshTokens[key]);\r\n\r\n        const numRefreshTokens = refreshTokens.length;\r\n        if (numRefreshTokens < 1) {\r\n            return null;\r\n        }\r\n        // address the else case after remove functions address environment aliases\r\n\r\n        return refreshTokens[0] as RefreshTokenEntity;\r\n    }\r\n\r\n    /**\r\n     * Retrieve AppMetadataEntity from cache\r\n     */\r\n    readAppMetadataFromCache(environment: string, clientId: string): AppMetadataEntity | null {\r\n        const appMetadataFilter: AppMetadataFilter = {\r\n            environment,\r\n            clientId,\r\n        };\r\n\r\n        const appMetadata: AppMetadataCache = this.getAppMetadataFilteredBy(appMetadataFilter);\r\n        const appMetadataEntries: AppMetadataEntity[] = Object.keys(appMetadata).map((key) => appMetadata[key]);\r\n\r\n        const numAppMetadata = appMetadataEntries.length;\r\n        if (numAppMetadata < 1) {\r\n            return null;\r\n        } else if (numAppMetadata > 1) {\r\n            throw ClientAuthError.createMultipleMatchingAppMetadataInCacheError();\r\n        }\r\n\r\n        return appMetadataEntries[0] as AppMetadataEntity;\r\n    }\r\n\r\n    /**\r\n     * Return the family_id value associated  with FOCI\r\n     * @param environment\r\n     * @param clientId\r\n     */\r\n    isAppMetadataFOCI(environment: string, clientId: string): boolean {\r\n        const appMetadata = this.readAppMetadataFromCache(environment, clientId);\r\n        return !!(appMetadata && appMetadata.familyId === THE_FAMILY_ID);\r\n    }\r\n\r\n    /**\r\n     * helper to match account ids\r\n     * @param value\r\n     * @param homeAccountId\r\n     */\r\n    private matchHomeAccountId(entity: AccountEntity | CredentialEntity, homeAccountId: string): boolean {\r\n        return !!(entity.homeAccountId && homeAccountId === entity.homeAccountId);\r\n    }\r\n\r\n    /**\r\n     * helper to match assertion\r\n     * @param value\r\n     * @param oboAssertion\r\n     */\r\n    private matchOboAssertion(entity: AccountEntity | CredentialEntity, oboAssertion: string): boolean {\r\n        return !!(entity.oboAssertion && oboAssertion === entity.oboAssertion);\r\n    }\r\n\r\n    /**\r\n     * helper to match environment\r\n     * @param value\r\n     * @param environment\r\n     */\r\n    private matchEnvironment(entity: AccountEntity | CredentialEntity | AppMetadataEntity, environment: string): boolean {\r\n        const cloudMetadata = this.getAuthorityMetadataByAlias(environment);\r\n        if (cloudMetadata && cloudMetadata.aliases.indexOf(entity.environment) > -1) {\r\n            return true;\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * helper to match credential type\r\n     * @param entity\r\n     * @param credentialType\r\n     */\r\n    private matchCredentialType(entity: CredentialEntity, credentialType: string): boolean {\r\n        return (entity.credentialType && credentialType.toLowerCase() === entity.credentialType.toLowerCase());\r\n    }\r\n\r\n    /**\r\n     * helper to match client ids\r\n     * @param entity\r\n     * @param clientId\r\n     */\r\n    private matchClientId(entity: CredentialEntity | AppMetadataEntity, clientId: string): boolean {\r\n        return !!(entity.clientId && clientId === entity.clientId);\r\n    }\r\n\r\n    /**\r\n     * helper to match family ids\r\n     * @param entity\r\n     * @param familyId\r\n     */\r\n    private matchFamilyId(entity: CredentialEntity | AppMetadataEntity, familyId: string): boolean {\r\n        return !!(entity.familyId && familyId === entity.familyId);\r\n    }\r\n\r\n    /**\r\n     * helper to match realm\r\n     * @param entity\r\n     * @param realm\r\n     */\r\n    private matchRealm(entity: AccountEntity | CredentialEntity, realm: string): boolean {\r\n        return !!(entity.realm && realm === entity.realm);\r\n    }\r\n\r\n    /**\r\n     * Returns true if the target scopes are a subset of the current entity's scopes, false otherwise.\r\n     * @param entity\r\n     * @param target\r\n     */\r\n    private matchTarget(entity: CredentialEntity, target: string): boolean {\r\n        if (entity.credentialType !== CredentialType.ACCESS_TOKEN || !entity.target) {\r\n            return false;\r\n        }\r\n\r\n        const entityScopeSet: ScopeSet = ScopeSet.fromString(entity.target);\r\n        const requestTargetScopeSet: ScopeSet = ScopeSet.fromString(target);\r\n\r\n        if (!requestTargetScopeSet.containsOnlyOIDCScopes()) {\r\n            requestTargetScopeSet.removeOIDCScopes(); // ignore OIDC scopes\r\n        }\r\n        return entityScopeSet.containsScopeSet(requestTargetScopeSet);\r\n    }\r\n\r\n    /**\r\n     * returns if a given cache entity is of the type appmetadata\r\n     * @param key\r\n     */\r\n    private isAppMetadata(key: string): boolean {\r\n        return key.indexOf(APP_METADATA) !== -1;\r\n    }\r\n\r\n    /**\r\n     * returns if a given cache entity is of the type authoritymetadata\r\n     * @param key\r\n     */\r\n    protected isAuthorityMetadata(key: string): boolean {\r\n        return key.indexOf(AUTHORITY_METADATA_CONSTANTS.CACHE_KEY) !== -1;\r\n    }\r\n\r\n    /**\r\n     * returns cache key used for cloud instance metadata\r\n     */\r\n    generateAuthorityMetadataCacheKey(authority: string): string {\r\n        return `${AUTHORITY_METADATA_CONSTANTS.CACHE_KEY}-${this.clientId}-${authority}`;\r\n    }\r\n\r\n    /**\r\n     * Returns the specific credential (IdToken/AccessToken/RefreshToken) from the cache\r\n     * @param key\r\n     * @param credType\r\n     */\r\n    private getSpecificCredential(key: string, credType: string): ValidCredentialType | null {\r\n        switch (credType) {\r\n            case CredentialType.ID_TOKEN: {\r\n                return this.getIdTokenCredential(key);\r\n            }\r\n            case CredentialType.ACCESS_TOKEN: {\r\n                return this.getAccessTokenCredential(key);\r\n            }\r\n            case CredentialType.REFRESH_TOKEN: {\r\n                return this.getRefreshTokenCredential(key);\r\n            }\r\n            default:\r\n                return null;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Helper to convert serialized data to object\r\n     * @param obj\r\n     * @param json\r\n     */\r\n    static toObject<T>(obj: T, json: object): T {\r\n        for (const propertyName in json) {\r\n            obj[propertyName] = json[propertyName];\r\n        }\r\n        return obj;\r\n    }\r\n}\r\n\r\nexport class DefaultStorageClass extends CacheManager {\r\n    setAccount(): void {\r\n        const notImplErr = \"Storage interface - setAccount() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    getAccount(): AccountEntity {\r\n        const notImplErr = \"Storage interface - getAccount() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    setIdTokenCredential(): void {\r\n        const notImplErr = \"Storage interface - setIdTokenCredential() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    getIdTokenCredential(): IdTokenEntity {\r\n        const notImplErr = \"Storage interface - getIdTokenCredential() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    setAccessTokenCredential(): void {\r\n        const notImplErr = \"Storage interface - setAccessTokenCredential() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    getAccessTokenCredential(): AccessTokenEntity {\r\n        const notImplErr = \"Storage interface - getAccessTokenCredential() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    setRefreshTokenCredential(): void {\r\n        const notImplErr = \"Storage interface - setRefreshTokenCredential() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    getRefreshTokenCredential(): RefreshTokenEntity {\r\n        const notImplErr = \"Storage interface - getRefreshTokenCredential() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    setAppMetadata(): void {\r\n        const notImplErr = \"Storage interface - setAppMetadata() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    getAppMetadata(): AppMetadataEntity {\r\n        const notImplErr = \"Storage interface - getAppMetadata() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    setServerTelemetry(): void {\r\n        const notImplErr = \"Storage interface - setServerTelemetry() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    getServerTelemetry(): ServerTelemetryEntity {\r\n        const notImplErr = \"Storage interface - getServerTelemetry() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    setAuthorityMetadata(): void {\r\n        const notImplErr = \"Storage interface - setAuthorityMetadata() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    getAuthorityMetadata(): AuthorityMetadataEntity | null {\r\n        const notImplErr = \"Storage interface - getAuthorityMetadata() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    getAuthorityMetadataKeys(): Array<string> {\r\n        const notImplErr = \"Storage interface - getAuthorityMetadataKeys() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    setThrottlingCache(): void {\r\n        const notImplErr = \"Storage interface - setThrottlingCache() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    getThrottlingCache(): ThrottlingEntity {\r\n        const notImplErr = \"Storage interface - getThrottlingCache() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    removeItem(): boolean {\r\n        const notImplErr = \"Storage interface - removeItem() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    containsKey(): boolean {\r\n        const notImplErr = \"Storage interface - containsKey() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    getKeys(): string[] {\r\n        const notImplErr = \"Storage interface - getKeys() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n    clear(): void {\r\n        const notImplErr = \"Storage interface - clear() has not been implemented for the cacheStorage interface.\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { INetworkModule } from \"../network/INetworkModule\";\r\nimport { DEFAULT_CRYPTO_IMPLEMENTATION, ICrypto } from \"../crypto/ICrypto\";\r\nimport { AuthError } from \"../error/AuthError\";\r\nimport { ILoggerCallback, LogLevel } from \"../logger/Logger\";\r\nimport { Constants } from \"../utils/Constants\";\r\nimport { version } from \"../packageMetadata\";\r\nimport { Authority } from \"../authority/Authority\";\r\nimport { CacheManager, DefaultStorageClass } from \"../cache/CacheManager\";\r\nimport { ServerTelemetryManager } from \"../telemetry/server/ServerTelemetryManager\";\r\nimport { ICachePlugin } from \"../cache/interface/ICachePlugin\";\r\nimport { ISerializableTokenCache } from \"../cache/interface/ISerializableTokenCache\";\r\n\r\n// Token renewal offset default in seconds\r\nconst DEFAULT_TOKEN_RENEWAL_OFFSET_SEC = 300;\r\n\r\n/**\r\n * Use the configuration object to configure MSAL Modules and initialize the base interfaces for MSAL.\r\n *\r\n * This object allows you to configure important elements of MSAL functionality:\r\n * - authOptions                - Authentication for application\r\n * - cryptoInterface            - Implementation of crypto functions\r\n * - libraryInfo                - Library metadata\r\n * - loggerOptions              - Logging for application\r\n * - networkInterface           - Network implementation\r\n * - storageInterface           - Storage implementation\r\n * - systemOptions              - Additional library options\r\n * - clientCredentials          - Credentials options for confidential clients\r\n */\r\nexport type ClientConfiguration = {\r\n    authOptions: AuthOptions,\r\n    systemOptions?: SystemOptions,\r\n    loggerOptions?: LoggerOptions,\r\n    storageInterface?: CacheManager,\r\n    networkInterface?: INetworkModule,\r\n    cryptoInterface?: ICrypto,\r\n    clientCredentials?: ClientCredentials,\r\n    libraryInfo?: LibraryInfo\r\n    serverTelemetryManager?: ServerTelemetryManager | null,\r\n    persistencePlugin?: ICachePlugin | null,\r\n    serializableCache?: ISerializableTokenCache | null\r\n};\r\n\r\nexport type CommonClientConfiguration = {\r\n    authOptions: Required<AuthOptions>,\r\n    systemOptions: Required<SystemOptions>,\r\n    loggerOptions : Required<LoggerOptions>,\r\n    storageInterface: CacheManager,\r\n    networkInterface : INetworkModule,\r\n    cryptoInterface : Required<ICrypto>,\r\n    libraryInfo : LibraryInfo,\r\n    serverTelemetryManager: ServerTelemetryManager | null,\r\n    clientCredentials: ClientCredentials,\r\n    persistencePlugin: ICachePlugin | null,\r\n    serializableCache: ISerializableTokenCache | null\r\n};\r\n\r\n/**\r\n * Use this to configure the auth options in the ClientConfiguration object\r\n *\r\n * - clientId                    - Client ID of your app registered with our Application registration portal : https://portal.azure.com/#blade/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/RegisteredAppsPreview in Microsoft Identity Platform\r\n * - authority                   - You can configure a specific authority, defaults to \" \" or \"https://login.microsoftonline.com/common\"\r\n * - knownAuthorities            - An array of URIs that are known to be valid. Used in B2C scenarios.\r\n * - cloudDiscoveryMetadata      - A string containing the cloud discovery response. Used in AAD scenarios.\r\n * - clientCapabilities          - Array of capabilities which will be added to the claims.access_token.xms_cc request property on every network request.\r\n * - protocolMode                - Enum that represents the protocol that msal follows. Used for configuring proper endpoints.\r\n */\r\nexport type AuthOptions = {\r\n    clientId: string;\r\n    authority: Authority;\r\n    clientCapabilities?: Array<string>;\r\n};\r\n\r\n/**\r\n * Use this to configure token renewal info in the Configuration object\r\n *\r\n * - tokenRenewalOffsetSeconds    - Sets the window of offset needed to renew the token before expiry\r\n */\r\nexport type SystemOptions = {\r\n    tokenRenewalOffsetSeconds?: number;\r\n};\r\n\r\n/**\r\n *  Use this to configure the logging that MSAL does, by configuring logger options in the Configuration object\r\n *\r\n * - loggerCallback                - Callback for logger\r\n * - piiLoggingEnabled             - Sets whether pii logging is enabled\r\n * - logLevel                      - Sets the level at which logging happens\r\n */\r\nexport type LoggerOptions = {\r\n    loggerCallback?: ILoggerCallback,\r\n    piiLoggingEnabled?: boolean,\r\n    logLevel?: LogLevel\r\n};\r\n\r\n/**\r\n * Library-specific options\r\n */\r\nexport type LibraryInfo = {\r\n    sku: string,\r\n    version: string,\r\n    cpu: string,\r\n    os: string\r\n};\r\n\r\n/**\r\n * Credentials for confidential clients\r\n */\r\nexport type ClientCredentials = {\r\n    clientSecret?: string,\r\n    clientAssertion? : {\r\n        assertion: string,\r\n        assertionType: string\r\n    };\r\n};\r\n\r\nexport const DEFAULT_SYSTEM_OPTIONS: Required<SystemOptions> = {\r\n    tokenRenewalOffsetSeconds: DEFAULT_TOKEN_RENEWAL_OFFSET_SEC\r\n};\r\n\r\nconst DEFAULT_LOGGER_IMPLEMENTATION: Required<LoggerOptions> = {\r\n    loggerCallback: () => {\r\n        // allow users to not set loggerCallback\r\n    },\r\n    piiLoggingEnabled: false,\r\n    logLevel: LogLevel.Info\r\n};\r\n\r\nconst DEFAULT_NETWORK_IMPLEMENTATION: INetworkModule = {\r\n    async sendGetRequestAsync<T>(): Promise<T> {\r\n        const notImplErr = \"Network interface - sendGetRequestAsync() has not been implemented\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    },\r\n    async sendPostRequestAsync<T>(): Promise<T> {\r\n        const notImplErr = \"Network interface - sendPostRequestAsync() has not been implemented\";\r\n        throw AuthError.createUnexpectedError(notImplErr);\r\n    }\r\n};\r\n\r\nconst DEFAULT_LIBRARY_INFO: LibraryInfo = {\r\n    sku: Constants.SKU,\r\n    version: version,\r\n    cpu: \"\",\r\n    os: \"\"\r\n};\r\n\r\nconst DEFAULT_CLIENT_CREDENTIALS: ClientCredentials = {\r\n    clientSecret: \"\",\r\n    clientAssertion: undefined\r\n};\r\n\r\n/**\r\n * Function that sets the default options when not explicitly configured from app developer\r\n *\r\n * @param Configuration\r\n *\r\n * @returns Configuration\r\n */\r\nexport function buildClientConfiguration(\r\n    {\r\n        authOptions: userAuthOptions,\r\n        systemOptions: userSystemOptions,\r\n        loggerOptions: userLoggerOption,\r\n        storageInterface: storageImplementation,\r\n        networkInterface: networkImplementation,\r\n        cryptoInterface: cryptoImplementation,\r\n        clientCredentials: clientCredentials,\r\n        libraryInfo: libraryInfo,\r\n        serverTelemetryManager: serverTelemetryManager,\r\n        persistencePlugin: persistencePlugin,\r\n        serializableCache: serializableCache\r\n    }: ClientConfiguration): CommonClientConfiguration {\r\n\r\n    return {\r\n        authOptions: buildAuthOptions(userAuthOptions),\r\n        systemOptions: { ...DEFAULT_SYSTEM_OPTIONS, ...userSystemOptions },\r\n        loggerOptions: { ...DEFAULT_LOGGER_IMPLEMENTATION, ...userLoggerOption },\r\n        storageInterface: storageImplementation || new DefaultStorageClass(userAuthOptions.clientId, DEFAULT_CRYPTO_IMPLEMENTATION),\r\n        networkInterface: networkImplementation || DEFAULT_NETWORK_IMPLEMENTATION,\r\n        cryptoInterface: cryptoImplementation || DEFAULT_CRYPTO_IMPLEMENTATION,\r\n        clientCredentials: clientCredentials || DEFAULT_CLIENT_CREDENTIALS,\r\n        libraryInfo: { ...DEFAULT_LIBRARY_INFO, ...libraryInfo },\r\n        serverTelemetryManager: serverTelemetryManager || null,\r\n        persistencePlugin: persistencePlugin || null,\r\n        serializableCache: serializableCache || null\r\n    };\r\n}\r\n\r\n/**\r\n * Construct authoptions from the client and platform passed values\r\n * @param authOptions\r\n */\r\nfunction buildAuthOptions(authOptions: AuthOptions): Required<AuthOptions> {\r\n    return {\r\n        clientCapabilities: [],\r\n        ...authOptions\r\n    };\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { AuthError } from \"./AuthError\";\r\n\r\n/**\r\n * Error thrown when there is an error with the server code, for example, unavailability.\r\n */\r\nexport class ServerError extends AuthError {\r\n\r\n    constructor(errorCode?: string, errorMessage?: string, subError?: string) {\r\n        super(errorCode, errorMessage, subError);\r\n        this.name = \"ServerError\";\r\n\r\n        Object.setPrototypeOf(this, ServerError.prototype);\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { NetworkResponse } from \"./NetworkManager\";\r\nimport { ServerAuthorizationTokenResponse } from \"../response/ServerAuthorizationTokenResponse\";\r\nimport { HeaderNames, CacheSchemaType, ThrottlingConstants, Constants } from \"../utils/Constants\";\r\nimport { CacheManager } from \"../cache/CacheManager\";\r\nimport { ServerError } from \"../error/ServerError\";\r\nimport { RequestThumbprint } from \"./RequestThumbprint\";\r\nimport { ThrottlingEntity } from \"../cache/entities/ThrottlingEntity\";\r\n\r\nexport class ThrottlingUtils {\r\n\r\n    /**\r\n     * Prepares a RequestThumbprint to be stored as a key.\r\n     * @param thumbprint\r\n     */\r\n    static generateThrottlingStorageKey(thumbprint: RequestThumbprint): string {\r\n        return `${ThrottlingConstants.THROTTLING_PREFIX}.${JSON.stringify(thumbprint)}`;\r\n    }\r\n\r\n    /**\r\n     * Performs necessary throttling checks before a network request.\r\n     * @param cacheManager\r\n     * @param thumbprint\r\n     */\r\n    static preProcess(cacheManager: CacheManager, thumbprint: RequestThumbprint): void {\r\n        const key = ThrottlingUtils.generateThrottlingStorageKey(thumbprint);\r\n        const value = cacheManager.getThrottlingCache(key);\r\n\r\n        if (value) {\r\n            if (value.throttleTime < Date.now()) {\r\n                cacheManager.removeItem(key, CacheSchemaType.THROTTLING);\r\n                return;\r\n            }\r\n            throw new ServerError(value.errorCodes?.join(\" \") || Constants.EMPTY_STRING, value.errorMessage, value.subError);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Performs necessary throttling checks after a network request.\r\n     * @param cacheManager\r\n     * @param thumbprint\r\n     * @param response\r\n     */\r\n    static postProcess(cacheManager: CacheManager, thumbprint: RequestThumbprint, response: NetworkResponse<ServerAuthorizationTokenResponse>): void {\r\n        if (ThrottlingUtils.checkResponseStatus(response) || ThrottlingUtils.checkResponseForRetryAfter(response)) {\r\n            const thumbprintValue: ThrottlingEntity = {\r\n                throttleTime: ThrottlingUtils.calculateThrottleTime(parseInt(response.headers[HeaderNames.RETRY_AFTER])),\r\n                error: response.body.error,\r\n                errorCodes: response.body.error_codes,\r\n                errorMessage: response.body.error_description,\r\n                subError: response.body.suberror\r\n            };\r\n            cacheManager.setThrottlingCache(\r\n                ThrottlingUtils.generateThrottlingStorageKey(thumbprint),\r\n                thumbprintValue\r\n            );\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Checks a NetworkResponse object's status codes against 429 or 5xx\r\n     * @param response\r\n     */\r\n    static checkResponseStatus(response: NetworkResponse<ServerAuthorizationTokenResponse>): boolean {\r\n        return response.status === 429 || response.status >= 500 && response.status < 600;\r\n    }\r\n\r\n    /**\r\n     * Checks a NetworkResponse object's RetryAfter header\r\n     * @param response\r\n     */\r\n    static checkResponseForRetryAfter(response: NetworkResponse<ServerAuthorizationTokenResponse>): boolean {\r\n        if (response.headers) {\r\n            return response.headers.hasOwnProperty(HeaderNames.RETRY_AFTER) && (response.status < 200 || response.status >= 300);\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Calculates the Unix-time value for a throttle to expire given throttleTime in seconds.\r\n     * @param throttleTime\r\n     */\r\n    static calculateThrottleTime(throttleTime: number): number {\r\n        if(throttleTime <= 0) {\r\n            throttleTime = 0;\r\n        }\r\n        const currentSeconds = Date.now() / 1000;\r\n        return Math.floor(Math.min(\r\n            currentSeconds + (throttleTime || ThrottlingConstants.DEFAULT_THROTTLE_TIME_SECONDS),\r\n            currentSeconds + ThrottlingConstants.DEFAULT_MAX_THROTTLE_TIME_SECONDS\r\n        ) * 1000);\r\n    }\r\n\r\n    static removeThrottle(cacheManager: CacheManager, clientId: string, authority: string, scopes: Array<string>, homeAccountIdentifier?: string): boolean {\r\n        const thumbprint: RequestThumbprint = {\r\n            clientId,\r\n            authority,\r\n            scopes,\r\n            homeAccountIdentifier\r\n        };\r\n\r\n        const key = this.generateThrottlingStorageKey(thumbprint);\r\n        return cacheManager.removeItem(key, CacheSchemaType.THROTTLING);\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { INetworkModule, NetworkRequestOptions } from \"./INetworkModule\";\r\nimport { RequestThumbprint } from \"./RequestThumbprint\";\r\nimport { ThrottlingUtils } from \"./ThrottlingUtils\";\r\nimport { CacheManager } from \"../cache/CacheManager\";\r\n\r\nexport type NetworkResponse<T> = {\r\n    headers: Record<string, string>;\r\n    body: T;\r\n    status: number;\r\n};\r\n\r\nexport class NetworkManager {\r\n    private networkClient: INetworkModule;\r\n    private cacheManager: CacheManager;\r\n\r\n    constructor(networkClient: INetworkModule, cacheManager: CacheManager) {\r\n        this.networkClient = networkClient;\r\n        this.cacheManager = cacheManager;\r\n    }\r\n\r\n    /**\r\n     * Wraps sendPostRequestAsync with necessary preflight and postflight logic\r\n     * @param thumbprint\r\n     * @param tokenEndpoint\r\n     * @param options\r\n     */\r\n    async sendPostRequest<T>(thumbprint: RequestThumbprint, tokenEndpoint: string, options: NetworkRequestOptions): Promise<NetworkResponse<T>> {\r\n        ThrottlingUtils.preProcess(this.cacheManager, thumbprint);\r\n        const response = await this.networkClient.sendPostRequestAsync<T>(tokenEndpoint, options);\r\n        ThrottlingUtils.postProcess(this.cacheManager, thumbprint, response);\r\n\r\n        // Placeholder for Telemetry hook\r\n\r\n        return response;\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { ClientConfiguration, buildClientConfiguration, CommonClientConfiguration } from \"../config/ClientConfiguration\";\r\nimport { INetworkModule } from \"../network/INetworkModule\";\r\nimport { NetworkManager, NetworkResponse } from \"../network/NetworkManager\";\r\nimport { ICrypto } from \"../crypto/ICrypto\";\r\nimport { Authority } from \"../authority/Authority\";\r\nimport { Logger } from \"../logger/Logger\";\r\nimport { AADServerParamKeys, Constants, HeaderNames } from \"../utils/Constants\";\r\nimport { ServerAuthorizationTokenResponse } from \"../response/ServerAuthorizationTokenResponse\";\r\nimport { CacheManager } from \"../cache/CacheManager\";\r\nimport { ServerTelemetryManager } from \"../telemetry/server/ServerTelemetryManager\";\r\nimport { RequestThumbprint } from \"../network/RequestThumbprint\";\r\nimport { version, name } from \"../packageMetadata\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\n\r\n/**\r\n * Base application class which will construct requests to send to and handle responses from the Microsoft STS using the authorization code flow.\r\n */\r\nexport abstract class BaseClient {\r\n    // Logger object\r\n    public logger: Logger;\r\n\r\n    // Application config\r\n    protected config: CommonClientConfiguration;\r\n\r\n    // Crypto Interface\r\n    protected cryptoUtils: ICrypto;\r\n\r\n    // Storage Interface\r\n    protected cacheManager: CacheManager;\r\n\r\n    // Network Interface\r\n    protected networkClient: INetworkModule;\r\n\r\n    // Server Telemetry Manager\r\n    protected serverTelemetryManager: ServerTelemetryManager | null;\r\n\r\n    // Network Manager\r\n    protected networkManager: NetworkManager;\r\n\r\n    // Default authority object\r\n    public authority: Authority;\r\n\r\n    protected constructor(configuration: ClientConfiguration) {\r\n        // Set the configuration\r\n        this.config = buildClientConfiguration(configuration);\r\n\r\n        // Initialize the logger\r\n        this.logger = new Logger(this.config.loggerOptions, name, version);\r\n\r\n        // Initialize crypto\r\n        this.cryptoUtils = this.config.cryptoInterface;\r\n\r\n        // Initialize storage interface\r\n        this.cacheManager = this.config.storageInterface;\r\n\r\n        // Set the network interface\r\n        this.networkClient = this.config.networkInterface;\r\n\r\n        // Set the NetworkManager\r\n        this.networkManager = new NetworkManager(this.networkClient, this.cacheManager);\r\n\r\n        // Set TelemetryManager\r\n        this.serverTelemetryManager = this.config.serverTelemetryManager;\r\n\r\n        // set Authority\r\n        this.authority = this.config.authOptions.authority;\r\n    }\r\n\r\n    /**\r\n     * Creates default headers for requests to token endpoint\r\n     */\r\n    protected createDefaultTokenRequestHeaders(): Record<string, string> {\r\n        const headers = this.createDefaultLibraryHeaders();\r\n        headers[HeaderNames.CONTENT_TYPE] = Constants.URL_FORM_CONTENT_TYPE;\r\n        headers[HeaderNames.X_MS_LIB_CAPABILITY] = HeaderNames.X_MS_LIB_CAPABILITY_VALUE;\r\n\r\n        if (this.serverTelemetryManager) {\r\n            headers[HeaderNames.X_CLIENT_CURR_TELEM] = this.serverTelemetryManager.generateCurrentRequestHeaderValue();\r\n            headers[HeaderNames.X_CLIENT_LAST_TELEM] = this.serverTelemetryManager.generateLastRequestHeaderValue();\r\n        }\r\n\r\n        return headers;\r\n    }\r\n\r\n    /**\r\n     * addLibraryData\r\n     */\r\n    protected createDefaultLibraryHeaders(): Record<string, string> {\r\n        const headers: Record<string, string> = {};\r\n\r\n        // client info headers\r\n        headers[AADServerParamKeys.X_CLIENT_SKU] = this.config.libraryInfo.sku;\r\n        headers[AADServerParamKeys.X_CLIENT_VER] = this.config.libraryInfo.version;\r\n        headers[AADServerParamKeys.X_CLIENT_OS] = this.config.libraryInfo.os;\r\n        headers[AADServerParamKeys.X_CLIENT_CPU] = this.config.libraryInfo.cpu;\r\n\r\n        return headers;\r\n    }\r\n\r\n    /**\r\n     * Http post to token endpoint\r\n     * @param tokenEndpoint\r\n     * @param queryString\r\n     * @param headers\r\n     * @param thumbprint\r\n     */\r\n    protected async executePostToTokenEndpoint(tokenEndpoint: string, queryString: string, headers: Record<string, string>, thumbprint: RequestThumbprint): Promise<NetworkResponse<ServerAuthorizationTokenResponse>> {\r\n        const response = await this.networkManager.sendPostRequest<ServerAuthorizationTokenResponse>(\r\n            thumbprint,\r\n            tokenEndpoint,\r\n            { body: queryString, headers: headers }\r\n        );\r\n\r\n        if (this.config.serverTelemetryManager && response.status < 500 && response.status !== 429) {\r\n            // Telemetry data successfully logged by server, clear Telemetry cache\r\n            this.config.serverTelemetryManager.clearTelemetryCache();\r\n        }\r\n\r\n        return response;\r\n    }\r\n\r\n    /**\r\n     * Updates the authority object of the client. Endpoint discovery must be completed.\r\n     * @param updatedAuthority \r\n     */\r\n    updateAuthority(updatedAuthority: Authority): void {\r\n        if (!updatedAuthority.discoveryComplete()) {\r\n            throw ClientAuthError.createEndpointDiscoveryIncompleteError(\"Updated authority has not completed endpoint discovery.\");\r\n        }\r\n        this.authority = updatedAuthority;\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\nimport { ClientConfigurationError } from \"../error/ClientConfigurationError\";\r\nimport { PromptValue, CodeChallengeMethodValues} from \"../utils/Constants\";\r\nimport { StringDict } from \"../utils/MsalTypes\";\r\n\r\n/**\r\n * Validates server consumable params from the \"request\" objects\r\n */\r\nexport class RequestValidator {\r\n\r\n    /**\r\n     * Utility to check if the `redirectUri` in the request is a non-null value\r\n     * @param redirectUri\r\n     */\r\n    static validateRedirectUri(redirectUri: string) : void {\r\n        if (StringUtils.isEmpty(redirectUri)) {\r\n            throw ClientConfigurationError.createRedirectUriEmptyError();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Utility to validate prompt sent by the user in the request\r\n     * @param prompt\r\n     */\r\n    static validatePrompt(prompt: string) : void {\r\n        if (\r\n            [\r\n                PromptValue.LOGIN,\r\n                PromptValue.SELECT_ACCOUNT,\r\n                PromptValue.CONSENT,\r\n                PromptValue.NONE\r\n            ].indexOf(prompt) < 0\r\n        ) {\r\n            throw ClientConfigurationError.createInvalidPromptError(prompt);\r\n        }\r\n    }\r\n\r\n    static validateClaims(claims: string) : void {\r\n        try {\r\n            JSON.parse(claims);\r\n        } catch(e) {\r\n            throw ClientConfigurationError.createInvalidClaimsRequestError();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Utility to validate code_challenge and code_challenge_method\r\n     * @param codeChallenge\r\n     * @param codeChallengeMethod\r\n     */\r\n    static validateCodeChallengeParams(codeChallenge: string, codeChallengeMethod: string) : void  {\r\n        if (StringUtils.isEmpty(codeChallenge) || StringUtils.isEmpty(codeChallengeMethod)) {\r\n            throw ClientConfigurationError.createInvalidCodeChallengeParamsError();\r\n        } else {\r\n            this.validateCodeChallengeMethod(codeChallengeMethod);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Utility to validate code_challenge_method\r\n     * @param codeChallengeMethod\r\n     */\r\n    static validateCodeChallengeMethod(codeChallengeMethod: string) : void {\r\n        if (\r\n            [\r\n                CodeChallengeMethodValues.PLAIN,\r\n                CodeChallengeMethodValues.S256\r\n            ].indexOf(codeChallengeMethod) < 0\r\n        ) {\r\n            throw ClientConfigurationError.createInvalidCodeChallengeMethodError();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Removes unnecessary or duplicate query parameters from extraQueryParameters\r\n     * @param request\r\n     */\r\n    static sanitizeEQParams(eQParams: StringDict, queryParams: Map<string, string>) : StringDict {\r\n        if (!eQParams) {\r\n            return {};\r\n        }\r\n\r\n        // Remove any query parameters already included in SSO params\r\n        queryParams.forEach((value, key) => {\r\n            if (eQParams[key]) {\r\n                delete eQParams[key];\r\n            }\r\n        });\r\n\r\n        return eQParams;\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { AADServerParamKeys, Constants, ResponseMode, SSOTypes, ClientInfo, AuthenticationScheme, ClaimsRequestKeys, PasswordGrantConstants, OIDC_DEFAULT_SCOPES} from \"../utils/Constants\";\r\nimport { ScopeSet } from \"./ScopeSet\";\r\nimport { ClientConfigurationError } from \"../error/ClientConfigurationError\";\r\nimport { StringDict } from \"../utils/MsalTypes\";\r\nimport { RequestValidator } from \"./RequestValidator\";\r\nimport { LibraryInfo } from \"../config/ClientConfiguration\";\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\n\r\nexport class RequestParameterBuilder {\r\n\r\n    private parameters: Map<string, string>;\r\n\r\n    constructor() {\r\n        this.parameters = new Map<string, string>();\r\n    }\r\n\r\n    /**\r\n     * add response_type = code\r\n     */\r\n    addResponseTypeCode(): void {\r\n        this.parameters.set(\r\n            AADServerParamKeys.RESPONSE_TYPE, encodeURIComponent(Constants.CODE_RESPONSE_TYPE)\r\n        );\r\n    }\r\n\r\n    /**\r\n     * add response_mode. defaults to query.\r\n     * @param responseMode\r\n     */\r\n    addResponseMode(responseMode?: ResponseMode): void {\r\n        this.parameters.set(\r\n            AADServerParamKeys.RESPONSE_MODE,\r\n            encodeURIComponent((responseMode) ? responseMode : ResponseMode.QUERY)\r\n        );\r\n    }\r\n\r\n    /**\r\n     * add scopes. set addOidcScopes to false to prevent default scopes in non-user scenarios\r\n     * @param scopeSet\r\n     * @param addOidcScopes\r\n     */\r\n    addScopes(scopes: string[], addOidcScopes: boolean = true): void {\r\n        const requestScopes = addOidcScopes ? [...scopes || [], ...OIDC_DEFAULT_SCOPES] : scopes || [];\r\n        const scopeSet = new ScopeSet(requestScopes);\r\n        this.parameters.set(AADServerParamKeys.SCOPE, encodeURIComponent(scopeSet.printScopes()));\r\n    }\r\n\r\n    /**\r\n     * add clientId\r\n     * @param clientId\r\n     */\r\n    addClientId(clientId: string): void {\r\n        this.parameters.set(AADServerParamKeys.CLIENT_ID, encodeURIComponent(clientId));\r\n    }\r\n\r\n    /**\r\n     * add redirect_uri\r\n     * @param redirectUri\r\n     */\r\n    addRedirectUri(redirectUri: string): void {\r\n        RequestValidator.validateRedirectUri(redirectUri);\r\n        this.parameters.set(AADServerParamKeys.REDIRECT_URI, encodeURIComponent(redirectUri));\r\n    }\r\n\r\n    /**\r\n     * add post logout redirectUri\r\n     * @param redirectUri\r\n     */\r\n    addPostLogoutRedirectUri(redirectUri: string): void {\r\n        RequestValidator.validateRedirectUri(redirectUri);\r\n        this.parameters.set(AADServerParamKeys.POST_LOGOUT_URI, encodeURIComponent(redirectUri));\r\n    }\r\n\r\n    /**\r\n     * add id_token_hint to logout request\r\n     * @param idTokenHint\r\n     */\r\n    addIdTokenHint(idTokenHint: string): void {\r\n        this.parameters.set(AADServerParamKeys.ID_TOKEN_HINT, encodeURIComponent(idTokenHint));\r\n    }\r\n\r\n    /**\r\n     * add domain_hint\r\n     * @param domainHint\r\n     */\r\n    addDomainHint(domainHint: string): void {\r\n        this.parameters.set(SSOTypes.DOMAIN_HINT, encodeURIComponent(domainHint));\r\n    }\r\n\r\n    /**\r\n     * add login_hint\r\n     * @param loginHint\r\n     */\r\n    addLoginHint(loginHint: string): void {\r\n        this.parameters.set(SSOTypes.LOGIN_HINT, encodeURIComponent(loginHint));\r\n    }\r\n\r\n    /**\r\n     * add sid\r\n     * @param sid\r\n     */\r\n    addSid(sid: string): void {\r\n        this.parameters.set(SSOTypes.SID, encodeURIComponent(sid));\r\n    }\r\n\r\n    /**\r\n     * add claims\r\n     * @param claims\r\n     */\r\n    addClaims(claims?: string, clientCapabilities?: Array<string>): void {\r\n        const mergedClaims = this.addClientCapabilitiesToClaims(claims, clientCapabilities);\r\n        RequestValidator.validateClaims(mergedClaims);\r\n        this.parameters.set(AADServerParamKeys.CLAIMS, encodeURIComponent(mergedClaims));\r\n    }\r\n\r\n    /**\r\n     * add correlationId\r\n     * @param correlationId\r\n     */\r\n    addCorrelationId(correlationId: string): void {\r\n        this.parameters.set(AADServerParamKeys.CLIENT_REQUEST_ID, encodeURIComponent(correlationId));\r\n    }\r\n\r\n    /**\r\n     * add library info query params\r\n     * @param libraryInfo\r\n     */\r\n    addLibraryInfo(libraryInfo: LibraryInfo): void {\r\n        // Telemetry Info\r\n        this.parameters.set(AADServerParamKeys.X_CLIENT_SKU, libraryInfo.sku);\r\n        this.parameters.set(AADServerParamKeys.X_CLIENT_VER, libraryInfo.version);\r\n        this.parameters.set(AADServerParamKeys.X_CLIENT_OS, libraryInfo.os);\r\n        this.parameters.set(AADServerParamKeys.X_CLIENT_CPU, libraryInfo.cpu);\r\n    }\r\n\r\n    /**\r\n     * add prompt\r\n     * @param prompt\r\n     */\r\n    addPrompt(prompt: string): void {\r\n        RequestValidator.validatePrompt(prompt);\r\n        this.parameters.set(`${AADServerParamKeys.PROMPT}`, encodeURIComponent(prompt));\r\n    }\r\n\r\n    /**\r\n     * add state\r\n     * @param state\r\n     */\r\n    addState(state: string): void {\r\n        if (!StringUtils.isEmpty(state)) {\r\n            this.parameters.set(AADServerParamKeys.STATE, encodeURIComponent(state));\r\n        }\r\n    }\r\n\r\n    /**\r\n     * add nonce\r\n     * @param nonce\r\n     */\r\n    addNonce(nonce: string): void {\r\n        this.parameters.set(AADServerParamKeys.NONCE, encodeURIComponent(nonce));\r\n    }\r\n\r\n    /**\r\n     * add code_challenge and code_challenge_method\r\n     * - throw if either of them are not passed\r\n     * @param codeChallenge\r\n     * @param codeChallengeMethod\r\n     */\r\n    addCodeChallengeParams(\r\n        codeChallenge: string,\r\n        codeChallengeMethod: string\r\n    ): void {\r\n        RequestValidator.validateCodeChallengeParams(codeChallenge, codeChallengeMethod);\r\n        if (codeChallenge && codeChallengeMethod) {\r\n            this.parameters.set(AADServerParamKeys.CODE_CHALLENGE, encodeURIComponent(codeChallenge));\r\n            this.parameters.set(AADServerParamKeys.CODE_CHALLENGE_METHOD, encodeURIComponent(codeChallengeMethod));\r\n        } else {\r\n            throw ClientConfigurationError.createInvalidCodeChallengeParamsError();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * add the `authorization_code` passed by the user to exchange for a token\r\n     * @param code\r\n     */\r\n    addAuthorizationCode(code: string): void {\r\n        this.parameters.set(AADServerParamKeys.CODE, encodeURIComponent(code));\r\n    }\r\n\r\n    /**\r\n     * add the `authorization_code` passed by the user to exchange for a token\r\n     * @param code\r\n     */\r\n    addDeviceCode(code: string): void {\r\n        this.parameters.set(AADServerParamKeys.DEVICE_CODE, encodeURIComponent(code));\r\n    }\r\n\r\n    /**\r\n     * add the `refreshToken` passed by the user\r\n     * @param refreshToken\r\n     */\r\n    addRefreshToken(refreshToken: string): void {\r\n        this.parameters.set(AADServerParamKeys.REFRESH_TOKEN, encodeURIComponent(refreshToken));\r\n    }\r\n\r\n    /**\r\n     * add the `code_verifier` passed by the user to exchange for a token\r\n     * @param codeVerifier\r\n     */\r\n    addCodeVerifier(codeVerifier: string): void {\r\n        this.parameters.set(AADServerParamKeys.CODE_VERIFIER, encodeURIComponent(codeVerifier));\r\n    }\r\n\r\n    /**\r\n     * add client_secret\r\n     * @param clientSecret\r\n     */\r\n    addClientSecret(clientSecret: string): void {\r\n        this.parameters.set(AADServerParamKeys.CLIENT_SECRET, encodeURIComponent(clientSecret));\r\n    }\r\n\r\n    /**\r\n     * add clientAssertion for confidential client flows\r\n     * @param clientAssertion\r\n     */\r\n    addClientAssertion(clientAssertion: string): void {\r\n        this.parameters.set(AADServerParamKeys.CLIENT_ASSERTION, encodeURIComponent(clientAssertion));\r\n    }\r\n\r\n    /**\r\n     * add clientAssertionType for confidential client flows\r\n     * @param clientAssertionType\r\n     */\r\n    addClientAssertionType(clientAssertionType: string): void {\r\n        this.parameters.set(AADServerParamKeys.CLIENT_ASSERTION_TYPE, encodeURIComponent(clientAssertionType));\r\n    }\r\n\r\n    /**\r\n     * add OBO assertion for confidential client flows\r\n     * @param clientAssertion\r\n     */\r\n    addOboAssertion(oboAssertion: string): void {\r\n        this.parameters.set(AADServerParamKeys.OBO_ASSERTION, encodeURIComponent(oboAssertion));\r\n    }\r\n\r\n    /**\r\n     * add grant type\r\n     * @param grantType\r\n     */\r\n    addRequestTokenUse(tokenUse: string): void {\r\n        this.parameters.set(AADServerParamKeys.REQUESTED_TOKEN_USE, encodeURIComponent(tokenUse));\r\n    }\r\n\r\n    /**\r\n     * add grant type\r\n     * @param grantType\r\n     */\r\n    addGrantType(grantType: string): void {\r\n        this.parameters.set(AADServerParamKeys.GRANT_TYPE, encodeURIComponent(grantType));\r\n    }\r\n\r\n    /**\r\n     * add client info\r\n     *\r\n     */\r\n    addClientInfo(): void {\r\n        this.parameters.set(ClientInfo, \"1\");\r\n    }\r\n\r\n    /**\r\n     * add extraQueryParams\r\n     * @param eQparams\r\n     */\r\n    addExtraQueryParameters(eQparams: StringDict): void {\r\n        RequestValidator.sanitizeEQParams(eQparams, this.parameters);\r\n        Object.keys(eQparams).forEach((key) => {\r\n            this.parameters.set(key, eQparams[key]);\r\n        });\r\n    }\r\n\r\n    addClientCapabilitiesToClaims(claims?: string, clientCapabilities?: Array<string>): string {\r\n        let mergedClaims: object;\r\n\r\n        // Parse provided claims into JSON object or initialize empty object\r\n        if (!claims) {\r\n            mergedClaims = {};\r\n        } else {\r\n            try {\r\n                mergedClaims = JSON.parse(claims);\r\n            } catch(e) {\r\n                throw ClientConfigurationError.createInvalidClaimsRequestError();\r\n            }\r\n        }\r\n\r\n        if (clientCapabilities && clientCapabilities.length > 0) {\r\n            if (!mergedClaims.hasOwnProperty(ClaimsRequestKeys.ACCESS_TOKEN)){\r\n                // Add access_token key to claims object\r\n                mergedClaims[ClaimsRequestKeys.ACCESS_TOKEN] = {};\r\n            }\r\n\r\n            // Add xms_cc claim with provided clientCapabilities to access_token key\r\n            mergedClaims[ClaimsRequestKeys.ACCESS_TOKEN][ClaimsRequestKeys.XMS_CC] = {\r\n                values: clientCapabilities\r\n            };\r\n        }\r\n\r\n        return JSON.stringify(mergedClaims);\r\n    }\r\n\r\n    /**\r\n     * adds `username` for Password Grant flow\r\n     * @param username\r\n     */\r\n    addUsername(username: string): void {\r\n        this.parameters.set(PasswordGrantConstants.username, username);\r\n    }\r\n\r\n    /**\r\n     * adds `password` for Password Grant flow\r\n     * @param password\r\n     */\r\n    addPassword(password: string): void {\r\n        this.parameters.set(PasswordGrantConstants.password, password);\r\n    }\r\n\r\n    /**\r\n     * add pop_jwk to query params\r\n     * @param cnfString\r\n     */\r\n    addPopToken(cnfString: string): void {\r\n        if (!StringUtils.isEmpty(cnfString)) {\r\n            this.parameters.set(AADServerParamKeys.TOKEN_TYPE, AuthenticationScheme.POP);\r\n            this.parameters.set(AADServerParamKeys.REQ_CNF, encodeURIComponent(cnfString));\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Utility to create a URL from the params map\r\n     */\r\n    createQueryString(): string {\r\n        const queryParameterArray: Array<string> = new Array<string>();\r\n\r\n        this.parameters.forEach((value, key) => {\r\n            queryParameterArray.push(`${key}=${value}`);\r\n        });\r\n\r\n        return queryParameterArray.join(\"&\");\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { CredentialEntity } from \"./CredentialEntity\";\r\nimport { CredentialType } from \"../../utils/Constants\";\r\n\r\n/**\r\n * ID_TOKEN Cache\r\n *\r\n * Key:Value Schema:\r\n *\r\n * Key Example: uid.utid-login.microsoftonline.com-idtoken-clientId-contoso.com-\r\n *\r\n * Value Schema:\r\n * {\r\n *      homeAccountId: home account identifier for the auth scheme,\r\n *      environment: entity that issued the token, represented as a full host\r\n *      credentialType: Type of credential as a string, can be one of the following: RefreshToken, AccessToken, IdToken, Password, Cookie, Certificate, Other\r\n *      clientId: client ID of the application\r\n *      secret: Actual credential as a string\r\n *      realm: Full tenant or organizational identifier that the account belongs to\r\n * }\r\n */\r\nexport class IdTokenEntity extends CredentialEntity {\r\n    realm: string;\r\n\r\n    /**\r\n     * Create IdTokenEntity\r\n     * @param homeAccountId\r\n     * @param authenticationResult\r\n     * @param clientId\r\n     * @param authority\r\n     */\r\n    static createIdTokenEntity(\r\n        homeAccountId: string,\r\n        environment: string,\r\n        idToken: string,\r\n        clientId: string,\r\n        tenantId: string,\r\n        oboAssertion?: string\r\n    ): IdTokenEntity {\r\n        const idTokenEntity = new IdTokenEntity();\r\n\r\n        idTokenEntity.credentialType = CredentialType.ID_TOKEN;\r\n        idTokenEntity.homeAccountId = homeAccountId;\r\n        idTokenEntity.environment = environment;\r\n        idTokenEntity.clientId = clientId;\r\n        idTokenEntity.secret = idToken;\r\n        idTokenEntity.realm = tenantId;\r\n        idTokenEntity.oboAssertion = oboAssertion;\r\n\r\n        return idTokenEntity;\r\n    }\r\n\r\n    /**\r\n     * Validates an entity: checks for all expected params\r\n     * @param entity\r\n     */\r\n    static isIdTokenEntity(entity: object): boolean {\r\n\r\n        if (!entity) {\r\n            return false;\r\n        }\r\n\r\n        return (\r\n            entity.hasOwnProperty(\"homeAccountId\") &&\r\n            entity.hasOwnProperty(\"environment\") &&\r\n            entity.hasOwnProperty(\"credentialType\") &&\r\n            entity.hasOwnProperty(\"realm\") &&\r\n            entity.hasOwnProperty(\"clientId\") &&\r\n            entity.hasOwnProperty(\"secret\") &&\r\n            entity[\"credentialType\"] === CredentialType.ID_TOKEN\r\n        );\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\n/**\r\n * Utility class which exposes functions for managing date and time operations.\r\n */\r\nexport class TimeUtils {\r\n\r\n    /**\r\n     * return the current time in Unix time (seconds).\r\n     */\r\n    static nowSeconds(): number {\r\n        // Date.getTime() returns in milliseconds.\r\n        return Math.round(new Date().getTime() / 1000.0);\r\n    }\r\n    \r\n    /**\r\n     * check if a token is expired based on given UTC time in seconds.\r\n     * @param expiresOn\r\n     */\r\n    static isTokenExpired(expiresOn: string, offset: number): boolean {\r\n        // check for access token expiry\r\n        const expirationSec = Number(expiresOn) || 0;\r\n        const offsetCurrentTimeSec = TimeUtils.nowSeconds() + offset; \r\n\r\n        // If current time + offset is greater than token expiration time, then token is expired.\r\n        return (offsetCurrentTimeSec > expirationSec);\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { CredentialEntity } from \"./CredentialEntity\";\r\nimport { CredentialType, AuthenticationScheme } from \"../../utils/Constants\";\r\nimport { TimeUtils } from \"../../utils/TimeUtils\";\r\nimport { StringUtils } from \"../../utils/StringUtils\";\r\n\r\n/**\r\n * ACCESS_TOKEN Credential Type\r\n *\r\n * Key:Value Schema:\r\n *\r\n * Key Example: uid.utid-login.microsoftonline.com-accesstoken-clientId-contoso.com-user.read\r\n *\r\n * Value Schema:\r\n * {\r\n *      homeAccountId: home account identifier for the auth scheme,\r\n *      environment: entity that issued the token, represented as a full host\r\n *      credentialType: Type of credential as a string, can be one of the following: RefreshToken, AccessToken, IdToken, Password, Cookie, Certificate, Other\r\n *      clientId: client ID of the application\r\n *      secret: Actual credential as a string\r\n *      familyId: Family ID identifier, usually only used for refresh tokens\r\n *      realm: Full tenant or organizational identifier that the account belongs to\r\n *      target: Permissions that are included in the token, or for refresh tokens, the resource identifier.\r\n *      cachedAt: Absolute device time when entry was created in the cache.\r\n *      expiresOn: Token expiry time, calculated based on current UTC time in seconds. Represented as a string.\r\n *      extendedExpiresOn: Additional extended expiry time until when token is valid in case of server-side outage. Represented as string in UTC seconds.\r\n *      keyId: used for POP and SSH tokenTypes\r\n *      tokenType: Type of the token issued. Usually \"Bearer\"\r\n * }\r\n */\r\nexport class AccessTokenEntity extends CredentialEntity {\r\n    realm: string;\r\n    target: string;\r\n    cachedAt: string;\r\n    expiresOn: string;\r\n    extendedExpiresOn?: string;\r\n    refreshOn?: string;\r\n    keyId?: string; // for POP and SSH tokenTypes\r\n    tokenType?: string;\r\n\r\n    /**\r\n     * Create AccessTokenEntity\r\n     * @param homeAccountId\r\n     * @param environment\r\n     * @param accessToken\r\n     * @param clientId\r\n     * @param tenantId\r\n     * @param scopes\r\n     * @param expiresOn\r\n     * @param extExpiresOn\r\n     */\r\n    static createAccessTokenEntity(\r\n        homeAccountId: string,\r\n        environment: string,\r\n        accessToken: string,\r\n        clientId: string,\r\n        tenantId: string,\r\n        scopes: string,\r\n        expiresOn: number,\r\n        extExpiresOn: number,\r\n        tokenType?: string,\r\n        oboAssertion?: string\r\n    ): AccessTokenEntity {\r\n        const atEntity: AccessTokenEntity = new AccessTokenEntity();\r\n\r\n        atEntity.homeAccountId = homeAccountId;\r\n        atEntity.credentialType = CredentialType.ACCESS_TOKEN;\r\n        atEntity.secret = accessToken;\r\n\r\n        const currentTime = TimeUtils.nowSeconds();\r\n        atEntity.cachedAt = currentTime.toString();\r\n\r\n        /*\r\n         * Token expiry time.\r\n         * This value should be  calculated based on the current UTC time measured locally and the value  expires_in Represented as a string in JSON.\r\n         */\r\n        atEntity.expiresOn = expiresOn.toString();\r\n        atEntity.extendedExpiresOn = extExpiresOn.toString();\r\n\r\n        atEntity.environment = environment;\r\n        atEntity.clientId = clientId;\r\n        atEntity.realm = tenantId;\r\n        atEntity.target = scopes;\r\n        atEntity.oboAssertion = oboAssertion;\r\n\r\n        atEntity.tokenType = StringUtils.isEmpty(tokenType) ? AuthenticationScheme.BEARER : tokenType;\r\n        return atEntity;\r\n    }\r\n\r\n    /**\r\n     * Validates an entity: checks for all expected params\r\n     * @param entity\r\n     */\r\n    static isAccessTokenEntity(entity: object): boolean {\r\n\r\n        if (!entity) {\r\n            return false;\r\n        }\r\n\r\n        return (\r\n            entity.hasOwnProperty(\"homeAccountId\") &&\r\n            entity.hasOwnProperty(\"environment\") &&\r\n            entity.hasOwnProperty(\"credentialType\") &&\r\n            entity.hasOwnProperty(\"realm\") &&\r\n            entity.hasOwnProperty(\"clientId\") &&\r\n            entity.hasOwnProperty(\"secret\") &&\r\n            entity.hasOwnProperty(\"target\") &&\r\n            entity[\"credentialType\"] === CredentialType.ACCESS_TOKEN\r\n        );\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { CredentialEntity } from \"./CredentialEntity\";\r\nimport { CredentialType } from \"../../utils/Constants\";\r\n\r\n/**\r\n * REFRESH_TOKEN Cache\r\n *\r\n * Key:Value Schema:\r\n *\r\n * Key Example: uid.utid-login.microsoftonline.com-refreshtoken-clientId--\r\n *\r\n * Value:\r\n * {\r\n *      homeAccountId: home account identifier for the auth scheme,\r\n *      environment: entity that issued the token, represented as a full host\r\n *      credentialType: Type of credential as a string, can be one of the following: RefreshToken, AccessToken, IdToken, Password, Cookie, Certificate, Other\r\n *      clientId: client ID of the application\r\n *      secret: Actual credential as a string\r\n *      familyId: Family ID identifier, '1' represents Microsoft Family\r\n *      realm: Full tenant or organizational identifier that the account belongs to\r\n *      target: Permissions that are included in the token, or for refresh tokens, the resource identifier.\r\n * }\r\n */\r\nexport class RefreshTokenEntity extends CredentialEntity {\r\n    familyId?: string;\r\n\r\n    /**\r\n     * Create RefreshTokenEntity\r\n     * @param homeAccountId\r\n     * @param authenticationResult\r\n     * @param clientId\r\n     * @param authority\r\n     */\r\n    static createRefreshTokenEntity(\r\n        homeAccountId: string,\r\n        environment: string,\r\n        refreshToken: string,\r\n        clientId: string,\r\n        familyId?: string,\r\n        oboAssertion?: string\r\n    ): RefreshTokenEntity {\r\n        const rtEntity = new RefreshTokenEntity();\r\n\r\n        rtEntity.clientId = clientId;\r\n        rtEntity.credentialType = CredentialType.REFRESH_TOKEN;\r\n        rtEntity.environment = environment;\r\n        rtEntity.homeAccountId = homeAccountId;\r\n        rtEntity.secret = refreshToken;\r\n        rtEntity.oboAssertion = oboAssertion;\r\n\r\n        if (familyId)\r\n            rtEntity.familyId = familyId;\r\n\r\n        return rtEntity;\r\n    }\r\n\r\n    /**\r\n     * Validates an entity: checks for all expected params\r\n     * @param entity\r\n     */\r\n    static isRefreshTokenEntity(entity: object): boolean {\r\n\r\n        if (!entity) {\r\n            return false;\r\n        }\r\n\r\n        return (\r\n            entity.hasOwnProperty(\"homeAccountId\") &&\r\n            entity.hasOwnProperty(\"environment\") &&\r\n            entity.hasOwnProperty(\"credentialType\") &&\r\n            entity.hasOwnProperty(\"clientId\") &&\r\n            entity.hasOwnProperty(\"secret\") &&\r\n            entity[\"credentialType\"] === CredentialType.REFRESH_TOKEN\r\n        );\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { ServerError } from \"./ServerError\";\r\n\r\n/**\r\n * InteractionRequiredAuthErrorMessage class containing string constants used by error codes and messages.\r\n */\r\nexport const InteractionRequiredAuthErrorMessage = [\r\n    \"interaction_required\",\r\n    \"consent_required\",\r\n    \"login_required\"\r\n];\r\n\r\nexport const InteractionRequiredAuthSubErrorMessage = [\r\n    \"message_only\",\r\n    \"additional_action\",\r\n    \"basic_action\",\r\n    \"user_password_expired\",\r\n    \"consent_required\"\r\n];\r\n\r\n/**\r\n * Error thrown when user interaction is required at the auth server.\r\n */\r\nexport class InteractionRequiredAuthError extends ServerError {\r\n\r\n    constructor(errorCode?: string, errorMessage?: string, subError?: string) {\r\n        super(errorCode, errorMessage, subError);\r\n        this.name = \"InteractionRequiredAuthError\";\r\n\r\n        Object.setPrototypeOf(this, InteractionRequiredAuthError.prototype);\r\n    }\r\n\r\n    static isInteractionRequiredError(errorCode?: string, errorString?: string, subError?: string) : boolean {\r\n        const isInteractionRequiredErrorCode = !!errorCode && InteractionRequiredAuthErrorMessage.indexOf(errorCode) > -1;\r\n        const isInteractionRequiredSubError = !!subError && InteractionRequiredAuthSubErrorMessage.indexOf(subError) > -1;\r\n        const isInteractionRequiredErrorDesc = !!errorString && InteractionRequiredAuthErrorMessage.some((irErrorCode) => {\r\n            return errorString.indexOf(irErrorCode) > -1;\r\n        });\r\n\r\n        return isInteractionRequiredErrorCode || isInteractionRequiredErrorDesc || isInteractionRequiredSubError;\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { IdTokenEntity } from \"./IdTokenEntity\";\r\nimport { AccessTokenEntity } from \"./AccessTokenEntity\";\r\nimport { RefreshTokenEntity } from \"./RefreshTokenEntity\";\r\nimport { AccountEntity } from \"./AccountEntity\";\r\nimport { AppMetadataEntity } from \"./AppMetadataEntity\";\r\n\r\nexport class CacheRecord {\r\n    account: AccountEntity | null;\r\n    idToken: IdTokenEntity | null;\r\n    accessToken: AccessTokenEntity | null;\r\n    refreshToken: RefreshTokenEntity | null;\r\n    appMetadata: AppMetadataEntity | null;\r\n\r\n    constructor(accountEntity?: AccountEntity | null, idTokenEntity?: IdTokenEntity | null, accessTokenEntity?: AccessTokenEntity | null, refreshTokenEntity?: RefreshTokenEntity | null, appMetadataEntity?: AppMetadataEntity | null) {\r\n        this.account = accountEntity || null;\r\n        this.idToken = idTokenEntity || null;\r\n        this.accessToken = accessTokenEntity || null;\r\n        this.refreshToken = refreshTokenEntity || null;\r\n        this.appMetadata = appMetadataEntity || null;\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { StringUtils } from \"./StringUtils\";\r\nimport { Constants } from \"./Constants\";\r\nimport { ICrypto } from \"../crypto/ICrypto\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\n\r\n/**\r\n * Type which defines the object that is stringified, encoded and sent in the state value.\r\n * Contains the following:\r\n * - id - unique identifier for this request\r\n * - ts - timestamp for the time the request was made. Used to ensure that token expiration is not calculated incorrectly.\r\n * - platformState - string value sent from the platform.\r\n */\r\nexport type LibraryStateObject = {\r\n    id: string,\r\n    meta?: Record<string, string>\r\n};\r\n\r\n/**\r\n * Type which defines the stringified and encoded object sent to the service in the authorize request.\r\n */\r\nexport type RequestStateObject = {\r\n    userRequestState: string,\r\n    libraryState: LibraryStateObject\r\n};\r\n\r\n/**\r\n * Class which provides helpers for OAuth 2.0 protocol specific values\r\n */\r\nexport class ProtocolUtils {\r\n\r\n    /**\r\n     * Appends user state with random guid, or returns random guid.\r\n     * @param userState \r\n     * @param randomGuid \r\n     */\r\n    static setRequestState(cryptoObj: ICrypto, userState?: string, meta?: Record<string, string>): string {\r\n        const libraryState = ProtocolUtils.generateLibraryState(cryptoObj, meta);\r\n        return !StringUtils.isEmpty(userState) ? `${libraryState}${Constants.RESOURCE_DELIM}${userState}` : libraryState;\r\n    }\r\n\r\n    /**\r\n     * Generates the state value used by the common library.\r\n     * @param randomGuid \r\n     * @param cryptoObj \r\n     */\r\n    static generateLibraryState(cryptoObj: ICrypto, meta?: Record<string, string>): string {\r\n        if (!cryptoObj) {\r\n            throw ClientAuthError.createNoCryptoObjectError(\"generateLibraryState\");\r\n        }\r\n\r\n        // Create a state object containing a unique id and the timestamp of the request creation\r\n        const stateObj: LibraryStateObject = {\r\n            id: cryptoObj.createNewGuid()\r\n        };\r\n\r\n        if (meta) {\r\n            stateObj.meta = meta;\r\n        }\r\n\r\n        const stateString = JSON.stringify(stateObj);\r\n\r\n        return cryptoObj.base64Encode(stateString);\r\n    }\r\n\r\n    /**\r\n     * Parses the state into the RequestStateObject, which contains the LibraryState info and the state passed by the user.\r\n     * @param state \r\n     * @param cryptoObj \r\n     */\r\n    static parseRequestState(cryptoObj: ICrypto, state: string): RequestStateObject {\r\n        if (!cryptoObj) {\r\n            throw ClientAuthError.createNoCryptoObjectError(\"parseRequestState\");\r\n        }\r\n\r\n        if (StringUtils.isEmpty(state)) {\r\n            throw ClientAuthError.createInvalidStateError(state, \"Null, undefined or empty state\");\r\n        }\r\n\r\n        try {\r\n            // Split the state between library state and user passed state and decode them separately\r\n            const splitState = decodeURIComponent(state).split(Constants.RESOURCE_DELIM);\r\n            const libraryState = splitState[0];\r\n            const userState = splitState.length > 1 ? splitState.slice(1).join(Constants.RESOURCE_DELIM) : \"\";\r\n            const libraryStateString = cryptoObj.base64Decode(libraryState);\r\n            const libraryStateObj = JSON.parse(libraryStateString) as LibraryStateObject;\r\n            return {\r\n                userRequestState: !StringUtils.isEmpty(userState) ? userState : \"\",\r\n                libraryState: libraryStateObj\r\n            };\r\n        } catch(e) {\r\n            throw ClientAuthError.createInvalidStateError(state, e);\r\n        }\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { ServerAuthorizationCodeResponse } from \"../response/ServerAuthorizationCodeResponse\";\r\nimport { ClientConfigurationError } from \"../error/ClientConfigurationError\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\nimport { IUri } from \"./IUri\";\r\nimport { AADAuthorityConstants, Constants } from \"../utils/Constants\";\r\n\r\n/**\r\n * Url object class which can perform various transformations on url strings.\r\n */\r\nexport class UrlString {\r\n\r\n    // internal url string field\r\n    private _urlString: string;\r\n    public get urlString(): string {\r\n        return this._urlString;\r\n    }\r\n    \r\n    constructor(url: string) {\r\n        this._urlString = url;\r\n        if (StringUtils.isEmpty(this._urlString)) {\r\n            // Throws error if url is empty\r\n            throw ClientConfigurationError.createUrlEmptyError();\r\n        }\r\n\r\n        if (StringUtils.isEmpty(this.getHash())) {\r\n            this._urlString = UrlString.canonicalizeUri(url);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Ensure urls are lower case and end with a / character.\r\n     * @param url \r\n     */\r\n    static canonicalizeUri(url: string): string {\r\n        if (url) {\r\n            url = url.toLowerCase();\r\n\r\n            if (StringUtils.endsWith(url, \"?\")) {\r\n                url = url.slice(0, -1);\r\n            } else if (StringUtils.endsWith(url, \"?/\")) {\r\n                url = url.slice(0, -2);\r\n            }\r\n\r\n            if (!StringUtils.endsWith(url, \"/\")) {\r\n                url += \"/\";\r\n            }\r\n        }\r\n\r\n        return url;\r\n    }\r\n\r\n    /**\r\n     * Throws if urlString passed is not a valid authority URI string.\r\n     */\r\n    validateAsUri(): void {\r\n        // Attempts to parse url for uri components\r\n        let components;\r\n        try {\r\n            components = this.getUrlComponents();\r\n        } catch (e) {\r\n            throw ClientConfigurationError.createUrlParseError(e);\r\n        }\r\n\r\n        // Throw error if URI or path segments are not parseable.\r\n        if (!components.HostNameAndPort || !components.PathSegments) {\r\n            throw ClientConfigurationError.createUrlParseError(`Given url string: ${this.urlString}`);\r\n        }\r\n\r\n        // Throw error if uri is insecure.\r\n        if(!components.Protocol || components.Protocol.toLowerCase() !== \"https:\") {\r\n            throw ClientConfigurationError.createInsecureAuthorityUriError(this.urlString);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Function to remove query string params from url. Returns the new url.\r\n     * @param url\r\n     * @param name\r\n     */\r\n    urlRemoveQueryStringParameter(name: string): string {\r\n        let regex = new RegExp(\"(\\\\&\" + name + \"=)[^\\&]+\");\r\n        this._urlString = this.urlString.replace(regex, \"\");\r\n        // name=value&\r\n        regex = new RegExp(\"(\" + name + \"=)[^\\&]+&\");\r\n        this._urlString = this.urlString.replace(regex, \"\");\r\n        // name=value\r\n        regex = new RegExp(\"(\" + name + \"=)[^\\&]+\");\r\n        this._urlString = this.urlString.replace(regex, \"\");\r\n        return this.urlString;\r\n    }\r\n\r\n    static removeHashFromUrl(url: string): string {\r\n        return UrlString.canonicalizeUri(url.split(\"#\")[0]);\r\n    }\r\n\r\n    /**\r\n     * Given a url like https://a:b/common/d?e=f#g, and a tenantId, returns https://a:b/tenantId/d\r\n     * @param href The url\r\n     * @param tenantId The tenant id to replace\r\n     */\r\n    replaceTenantPath(tenantId: string): UrlString {\r\n        const urlObject = this.getUrlComponents();\r\n        const pathArray = urlObject.PathSegments;\r\n        if (tenantId && (pathArray.length !== 0 && (pathArray[0] === AADAuthorityConstants.COMMON || pathArray[0] === AADAuthorityConstants.ORGANIZATIONS))) {\r\n            pathArray[0] = tenantId;\r\n        }\r\n        return UrlString.constructAuthorityUriFromObject(urlObject);\r\n    }\r\n\r\n    /**\r\n     * Returns the anchor part(#) of the URL\r\n     */\r\n    getHash(): string {\r\n        return UrlString.parseHash(this.urlString);\r\n    }\r\n\r\n    /**\r\n     * Parses out the components from a url string.\r\n     * @returns An object with the various components. Please cache this value insted of calling this multiple times on the same url.\r\n     */\r\n    getUrlComponents(): IUri {\r\n        // https://gist.github.com/curtisz/11139b2cfcaef4a261e0\r\n        const regEx = RegExp(\"^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\\\?([^#]*))?(#(.*))?\");\r\n\r\n        // If url string does not match regEx, we throw an error\r\n        const match = this.urlString.match(regEx);\r\n        if (!match) {\r\n            throw ClientConfigurationError.createUrlParseError(`Given url string: ${this.urlString}`);\r\n        }\r\n\r\n        // Url component object\r\n        const urlComponents = {\r\n            Protocol: match[1],\r\n            HostNameAndPort: match[4],\r\n            AbsolutePath: match[5],\r\n            QueryString: match[7]\r\n        } as IUri;\r\n\r\n        let pathSegments = urlComponents.AbsolutePath.split(\"/\");\r\n        pathSegments = pathSegments.filter((val) => val && val.length > 0); // remove empty elements\r\n        urlComponents.PathSegments = pathSegments;\r\n\r\n        if (!StringUtils.isEmpty(urlComponents.QueryString) && urlComponents.QueryString.endsWith(\"/\")) {\r\n            urlComponents.QueryString = urlComponents.QueryString.substring(0, urlComponents.QueryString.length-1);\r\n        }\r\n        return urlComponents;\r\n    }\r\n\r\n    static getDomainFromUrl(url: string): string {\r\n        const regEx = RegExp(\"^([^:/?#]+://)?([^/?#]*)\");\r\n\r\n        const match = url.match(regEx);\r\n\r\n        if (!match) {\r\n            throw ClientConfigurationError.createUrlParseError(`Given url string: ${url}`);\r\n        }\r\n\r\n        return match[2];\r\n    }\r\n\r\n    static getAbsoluteUrl(relativeUrl: string, baseUrl: string): string {\r\n        if (relativeUrl[0] === Constants.FORWARD_SLASH) {\r\n            const url = new UrlString(baseUrl);\r\n            const baseComponents = url.getUrlComponents();\r\n\r\n            return baseComponents.Protocol + \"//\" + baseComponents.HostNameAndPort + relativeUrl;\r\n        }\r\n        \r\n        return relativeUrl;\r\n    }\r\n    \r\n    /**\r\n     * Parses hash string from given string. Returns empty string if no hash symbol is found.\r\n     * @param hashString \r\n     */\r\n    static parseHash(hashString: string): string {\r\n        const hashIndex1 = hashString.indexOf(\"#\");\r\n        const hashIndex2 = hashString.indexOf(\"#/\");\r\n        if (hashIndex2 > -1) {\r\n            return hashString.substring(hashIndex2 + 2);\r\n        } else if (hashIndex1 > -1) {\r\n            return hashString.substring(hashIndex1 + 1);\r\n        }\r\n        return \"\";\r\n    }\r\n\r\n    static constructAuthorityUriFromObject(urlObject: IUri): UrlString {\r\n        return new UrlString(urlObject.Protocol + \"//\" + urlObject.HostNameAndPort + \"/\" + urlObject.PathSegments.join(\"/\"));\r\n    }\r\n\r\n    /**\r\n     * Returns URL hash as server auth code response object.\r\n     */\r\n    static getDeserializedHash(hash: string): ServerAuthorizationCodeResponse {\r\n        // Check if given hash is empty\r\n        if (StringUtils.isEmpty(hash)) {\r\n            return {};\r\n        }\r\n        // Strip the # symbol if present\r\n        const parsedHash = UrlString.parseHash(hash);\r\n        // If # symbol was not present, above will return empty string, so give original hash value\r\n        const deserializedHash: ServerAuthorizationCodeResponse = StringUtils.queryStringToObject<ServerAuthorizationCodeResponse>(StringUtils.isEmpty(parsedHash) ? hash : parsedHash);\r\n        // Check if deserialization didn't work\r\n        if (!deserializedHash) {\r\n            throw ClientAuthError.createHashNotDeserializedError(JSON.stringify(deserializedHash));\r\n        }\r\n        return deserializedHash;\r\n    }\r\n\r\n    /**\r\n     * Check if the hash of the URL string contains known properties\r\n     */\r\n    static hashContainsKnownProperties(hash: string): boolean {\r\n        if (StringUtils.isEmpty(hash)) {\r\n            return false;\r\n        }\r\n\r\n        const parameters: ServerAuthorizationCodeResponse = UrlString.getDeserializedHash(hash);\r\n        return !!(\r\n            parameters.code ||\r\n            parameters.error_description ||\r\n            parameters.error ||\r\n            parameters.state\r\n        );\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { ICrypto } from \"./ICrypto\";\r\nimport { AuthToken } from \"../account/AuthToken\";\r\nimport { TokenClaims } from \"../account/TokenClaims\";\r\nimport { TimeUtils } from \"../utils/TimeUtils\";\r\nimport { UrlString } from \"../url/UrlString\";\r\nimport { IUri } from \"../url/IUri\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\n\r\n/**\r\n * See eSTS docs for more info.\r\n * - A kid element, with the value containing an RFC 7638-compliant JWK thumbprint that is base64 encoded.\r\n * -  xms_ksl element, representing the storage location of the key's secret component on the client device. One of two values:\r\n *      - sw: software storage\r\n *      - uhw: hardware storage\r\n */\r\ntype ReqCnf = {\r\n    kid: string;\r\n    xms_ksl: KeyLocation;\r\n};\r\n\r\nenum KeyLocation {\r\n    SW = \"sw\",\r\n    UHW = \"uhw\"\r\n}\r\n\r\nexport class PopTokenGenerator {\r\n\r\n    private cryptoUtils: ICrypto;\r\n\r\n    constructor(cryptoUtils: ICrypto) {\r\n        this.cryptoUtils = cryptoUtils;\r\n    }\r\n\r\n    async generateCnf(resourceRequestMethod: string, resourceRequestUri: string): Promise<string> {\r\n        const kidThumbprint = await this.cryptoUtils.getPublicKeyThumbprint(resourceRequestMethod, resourceRequestUri);\r\n        const reqCnf: ReqCnf = {\r\n            kid: kidThumbprint,\r\n            xms_ksl: KeyLocation.SW\r\n        };\r\n        return this.cryptoUtils.base64Encode(JSON.stringify(reqCnf));\r\n    }\r\n\r\n    async signPopToken(accessToken: string, resourceRequestMethod: string, resourceRequestUri: string): Promise<string> {\r\n        const tokenClaims: TokenClaims | null = AuthToken.extractTokenClaims(accessToken, this.cryptoUtils);\r\n        const resourceUrlString: UrlString = new UrlString(resourceRequestUri);\r\n        const resourceUrlComponents: IUri = resourceUrlString.getUrlComponents();\r\n\r\n        if (!tokenClaims?.cnf?.kid) {\r\n            throw ClientAuthError.createTokenClaimsRequiredError();\r\n        }\r\n\r\n        return await this.cryptoUtils.signJwt({\r\n            at: accessToken,\r\n            ts: `${TimeUtils.nowSeconds()}`,\r\n            m: resourceRequestMethod.toUpperCase(),\r\n            u: resourceUrlComponents.HostNameAndPort || \"\",\r\n            nonce: this.cryptoUtils.createNewGuid(),\r\n            p: resourceUrlComponents.AbsolutePath,\r\n            q: [[], resourceUrlComponents.QueryString],\r\n        }, tokenClaims.cnf.kid);\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { APP_METADATA, Separators } from \"../../utils/Constants\";\r\n\r\n/**\r\n * APP_METADATA Cache\r\n *\r\n * Key:Value Schema:\r\n *\r\n * Key: appmetadata-<environment>-<client_id>\r\n *\r\n * Value:\r\n * {\r\n *      clientId: client ID of the application\r\n *      environment: entity that issued the token, represented as a full host\r\n *      familyId: Family ID identifier, '1' represents Microsoft Family\r\n * }\r\n */\r\nexport class AppMetadataEntity {\r\n    clientId: string;\r\n    environment: string;\r\n    familyId?: string;\r\n\r\n    /**\r\n     * Generate AppMetadata Cache Key as per the schema: appmetadata-<environment>-<client_id>\r\n     */\r\n    generateAppMetadataKey(): string {\r\n        return AppMetadataEntity.generateAppMetadataCacheKey(this.environment, this.clientId);\r\n    }\r\n\r\n    /**\r\n     * Generate AppMetadata Cache Key\r\n     */\r\n    static generateAppMetadataCacheKey(environment: string, clientId: string): string {\r\n        const appMetaDataKeyArray: Array<string> = [\r\n            APP_METADATA,\r\n            environment,\r\n            clientId,\r\n        ];\r\n        return appMetaDataKeyArray.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();\r\n    }\r\n\r\n    /**\r\n     * Creates AppMetadataEntity\r\n     * @param clientId\r\n     * @param environment\r\n     * @param familyId\r\n     */\r\n    static createAppMetadataEntity(clientId: string, environment: string, familyId?: string): AppMetadataEntity {\r\n        const appMetadata = new AppMetadataEntity();\r\n\r\n        appMetadata.clientId = clientId;\r\n        appMetadata.environment = environment;\r\n        if (familyId) {\r\n            appMetadata.familyId = familyId;\r\n        }\r\n\r\n        return appMetadata;\r\n    }\r\n\r\n    /**\r\n     * Validates an entity: checks for all expected params\r\n     * @param entity\r\n     */\r\n    static isAppMetadataEntity(key: string, entity: object): boolean {\r\n\r\n        if (!entity) {\r\n            return false;\r\n        }\r\n\r\n        return (\r\n            key.indexOf(APP_METADATA) === 0 &&\r\n            entity.hasOwnProperty(\"clientId\") &&\r\n            entity.hasOwnProperty(\"environment\")\r\n        );\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { ISerializableTokenCache } from \"../interface/ISerializableTokenCache\";\r\n\r\n/**\r\n * This class instance helps track the memory changes facilitating\r\n * decisions to read from and write to the persistent cache\r\n */export class TokenCacheContext {\r\n    /**\r\n     * boolean indicating cache change\r\n     */\r\n    hasChanged: boolean;\r\n    /**\r\n     * serializable token cache interface\r\n     */\r\n    cache: ISerializableTokenCache;\r\n\r\n    constructor(tokenCache: ISerializableTokenCache, hasChanged: boolean) {\r\n        this.cache = tokenCache;\r\n        this.hasChanged = hasChanged;\r\n    }\r\n\r\n    /**\r\n     * boolean which indicates the changes in cache\r\n     */\r\n    get cacheHasChanged(): boolean {\r\n        return this.hasChanged;\r\n    }\r\n\r\n    /**\r\n     * function to retrieve the token cache\r\n     */\r\n    get tokenCache(): ISerializableTokenCache {\r\n        return this.cache;\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { ServerAuthorizationTokenResponse } from \"./ServerAuthorizationTokenResponse\";\r\nimport { buildClientInfo} from \"../account/ClientInfo\";\r\nimport { ICrypto } from \"../crypto/ICrypto\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\nimport { ServerAuthorizationCodeResponse } from \"./ServerAuthorizationCodeResponse\";\r\nimport { Logger } from \"../logger/Logger\";\r\nimport { ServerError } from \"../error/ServerError\";\r\nimport { AuthToken } from \"../account/AuthToken\";\r\nimport { ScopeSet } from \"../request/ScopeSet\";\r\nimport { AuthenticationResult } from \"./AuthenticationResult\";\r\nimport { AccountEntity } from \"../cache/entities/AccountEntity\";\r\nimport { Authority } from \"../authority/Authority\";\r\nimport { AuthorityType } from \"../authority/AuthorityType\";\r\nimport { IdTokenEntity } from \"../cache/entities/IdTokenEntity\";\r\nimport { AccessTokenEntity } from \"../cache/entities/AccessTokenEntity\";\r\nimport { RefreshTokenEntity } from \"../cache/entities/RefreshTokenEntity\";\r\nimport { InteractionRequiredAuthError } from \"../error/InteractionRequiredAuthError\";\r\nimport { CacheRecord } from \"../cache/entities/CacheRecord\";\r\nimport { CacheManager } from \"../cache/CacheManager\";\r\nimport { ProtocolUtils, RequestStateObject } from \"../utils/ProtocolUtils\";\r\nimport { AuthenticationScheme, Constants, THE_FAMILY_ID } from \"../utils/Constants\";\r\nimport { PopTokenGenerator } from \"../crypto/PopTokenGenerator\";\r\nimport { AppMetadataEntity } from \"../cache/entities/AppMetadataEntity\";\r\nimport { ICachePlugin } from \"../cache/interface/ICachePlugin\";\r\nimport { TokenCacheContext } from \"../cache/persistence/TokenCacheContext\";\r\nimport { ISerializableTokenCache } from \"../cache/interface/ISerializableTokenCache\";\r\nimport { AuthorizationCodePayload } from \"./AuthorizationCodePayload\";\r\nimport { ClientConfigurationError } from \"../error/ClientConfigurationError\";\r\n\r\n/**\r\n * Class that handles response parsing.\r\n */\r\nexport class ResponseHandler {\r\n    private clientId: string;\r\n    private cacheStorage: CacheManager;\r\n    private cryptoObj: ICrypto;\r\n    private logger: Logger;\r\n    private homeAccountIdentifier: string;\r\n    private serializableCache: ISerializableTokenCache | null;\r\n    private persistencePlugin: ICachePlugin | null;\r\n\r\n    constructor(clientId: string, cacheStorage: CacheManager, cryptoObj: ICrypto, logger: Logger, serializableCache: ISerializableTokenCache | null, persistencePlugin: ICachePlugin | null) {\r\n        this.clientId = clientId;\r\n        this.cacheStorage = cacheStorage;\r\n        this.cryptoObj = cryptoObj;\r\n        this.logger = logger;\r\n        this.serializableCache = serializableCache;\r\n        this.persistencePlugin = persistencePlugin;\r\n    }\r\n\r\n    /**\r\n     * Function which validates server authorization code response.\r\n     * @param serverResponseHash\r\n     * @param cachedState\r\n     * @param cryptoObj\r\n     */\r\n    validateServerAuthorizationCodeResponse(serverResponseHash: ServerAuthorizationCodeResponse, cachedState: string, cryptoObj: ICrypto): void {\r\n\r\n        if (!serverResponseHash.state || !cachedState) {\r\n            throw !serverResponseHash.state ? ClientAuthError.createStateNotFoundError(\"Server State\") : ClientAuthError.createStateNotFoundError(\"Cached State\");\r\n        }\r\n\r\n        if (decodeURIComponent(serverResponseHash.state) !== decodeURIComponent(cachedState)) {\r\n            throw ClientAuthError.createStateMismatchError();\r\n        }\r\n\r\n        // Check for error\r\n        if (serverResponseHash.error || serverResponseHash.error_description || serverResponseHash.suberror) {\r\n            if (InteractionRequiredAuthError.isInteractionRequiredError(serverResponseHash.error, serverResponseHash.error_description, serverResponseHash.suberror)) {\r\n                throw new InteractionRequiredAuthError(serverResponseHash.error || Constants.EMPTY_STRING, serverResponseHash.error_description, serverResponseHash.suberror);\r\n            }\r\n\r\n            throw new ServerError(serverResponseHash.error || Constants.EMPTY_STRING, serverResponseHash.error_description, serverResponseHash.suberror);\r\n        }\r\n\r\n        if (serverResponseHash.client_info) {\r\n            buildClientInfo(serverResponseHash.client_info, cryptoObj);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Function which validates server authorization token response.\r\n     * @param serverResponse\r\n     */\r\n    validateTokenResponse(serverResponse: ServerAuthorizationTokenResponse): void {\r\n        // Check for error\r\n        if (serverResponse.error || serverResponse.error_description || serverResponse.suberror) {\r\n            if (InteractionRequiredAuthError.isInteractionRequiredError(serverResponse.error, serverResponse.error_description, serverResponse.suberror)) {\r\n                throw new InteractionRequiredAuthError(serverResponse.error, serverResponse.error_description, serverResponse.suberror);\r\n            }\r\n\r\n            const errString = `${serverResponse.error_codes} - [${serverResponse.timestamp}]: ${serverResponse.error_description} - Correlation ID: ${serverResponse.correlation_id} - Trace ID: ${serverResponse.trace_id}`;\r\n            throw new ServerError(serverResponse.error, errString);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns a constructed token response based on given string. Also manages the cache updates and cleanups.\r\n     * @param serverTokenResponse\r\n     * @param authority\r\n     */\r\n    async handleServerTokenResponse(\r\n        serverTokenResponse: ServerAuthorizationTokenResponse,\r\n        authority: Authority,\r\n        reqTimestamp: number,\r\n        resourceRequestMethod?: string,\r\n        resourceRequestUri?: string,\r\n        authCodePayload?: AuthorizationCodePayload,\r\n        requestScopes?: string[],\r\n        oboAssertion?: string,\r\n        handlingRefreshTokenResponse?: boolean): Promise<AuthenticationResult> {\r\n\r\n        // create an idToken object (not entity)\r\n        let idTokenObj: AuthToken | undefined;\r\n        if (serverTokenResponse.id_token) {\r\n            idTokenObj = new AuthToken(serverTokenResponse.id_token || Constants.EMPTY_STRING, this.cryptoObj);\r\n    \r\n            // token nonce check (TODO: Add a warning if no nonce is given?)\r\n            if (authCodePayload && !StringUtils.isEmpty(authCodePayload.nonce)) {\r\n                if (idTokenObj.claims.nonce !== authCodePayload.nonce) {\r\n                    throw ClientAuthError.createNonceMismatchError();\r\n                }\r\n            }\r\n        }\r\n\r\n        // generate homeAccountId\r\n        this.homeAccountIdentifier = AccountEntity.generateHomeAccountId(serverTokenResponse.client_info || Constants.EMPTY_STRING, authority.authorityType, this.logger, this.cryptoObj, idTokenObj);\r\n\r\n        // save the response tokens\r\n        let requestStateObj: RequestStateObject | undefined;\r\n        if (!!authCodePayload && !!authCodePayload.state) {\r\n            requestStateObj = ProtocolUtils.parseRequestState(this.cryptoObj, authCodePayload.state);\r\n        }\r\n\r\n        const cacheRecord = this.generateCacheRecord(serverTokenResponse, authority, reqTimestamp, idTokenObj, requestScopes, oboAssertion, authCodePayload);\r\n        let cacheContext;\r\n        try {\r\n            if (this.persistencePlugin && this.serializableCache) {\r\n                this.logger.verbose(\"Persistence enabled, calling beforeCacheAccess\");\r\n                cacheContext = new TokenCacheContext(this.serializableCache, true);\r\n                await this.persistencePlugin.beforeCacheAccess(cacheContext);\r\n            }\r\n            /*\r\n             * When saving a refreshed tokens to the cache, it is expected that the account that was used is present in the cache.\r\n             * If not present, we should return null, as it's the case that another application called removeAccount in between\r\n             * the calls to getAllAccounts and acquireTokenSilent. We should not overwrite that removal.\r\n             */\r\n            if (handlingRefreshTokenResponse && cacheRecord.account) {\r\n                const key = cacheRecord.account.generateAccountKey();\r\n                const account = this.cacheStorage.getAccount(key);\r\n                if (!account) {\r\n                    this.logger.warning(\"Account used to refresh tokens not in persistence, refreshed tokens will not be stored in the cache\");\r\n                    return ResponseHandler.generateAuthenticationResult(this.cryptoObj, authority, cacheRecord, false, idTokenObj, requestStateObj, resourceRequestMethod, resourceRequestUri);\r\n                }\r\n            }\r\n            this.cacheStorage.saveCacheRecord(cacheRecord);\r\n        } finally {\r\n            if (this.persistencePlugin && this.serializableCache && cacheContext) {\r\n                this.logger.verbose(\"Persistence enabled, calling afterCacheAccess\");\r\n                await this.persistencePlugin.afterCacheAccess(cacheContext);\r\n            }\r\n        }\r\n        return ResponseHandler.generateAuthenticationResult(this.cryptoObj, authority, cacheRecord, false, idTokenObj, requestStateObj, resourceRequestMethod, resourceRequestUri);\r\n    }\r\n\r\n    /**\r\n     * Generates CacheRecord\r\n     * @param serverTokenResponse\r\n     * @param idTokenObj\r\n     * @param authority\r\n     */\r\n    private generateCacheRecord(serverTokenResponse: ServerAuthorizationTokenResponse, authority: Authority, reqTimestamp: number, idTokenObj?: AuthToken, requestScopes?: string[], oboAssertion?: string, authCodePayload?: AuthorizationCodePayload): CacheRecord {\r\n        const env = authority.getPreferredCache();\r\n        if (StringUtils.isEmpty(env)) {\r\n            throw ClientAuthError.createInvalidCacheEnvironmentError();\r\n        }\r\n\r\n        // IdToken: non AAD scenarios can have empty realm\r\n        let cachedIdToken: IdTokenEntity | undefined;\r\n        let cachedAccount: AccountEntity | undefined;\r\n        if (!StringUtils.isEmpty(serverTokenResponse.id_token) && !!idTokenObj) {\r\n            cachedIdToken = IdTokenEntity.createIdTokenEntity(\r\n                this.homeAccountIdentifier,\r\n                env,\r\n                serverTokenResponse.id_token || Constants.EMPTY_STRING,\r\n                this.clientId,\r\n                idTokenObj.claims.tid || Constants.EMPTY_STRING,\r\n                oboAssertion\r\n            );\r\n\r\n            cachedAccount = this.generateAccountEntity(\r\n                serverTokenResponse,\r\n                idTokenObj,\r\n                authority,\r\n                oboAssertion,\r\n                authCodePayload\r\n            );\r\n        }\r\n\r\n        // AccessToken\r\n        let cachedAccessToken: AccessTokenEntity | null = null;\r\n        if (!StringUtils.isEmpty(serverTokenResponse.access_token)) {\r\n\r\n            // If scopes not returned in server response, use request scopes\r\n            const responseScopes = serverTokenResponse.scope ? ScopeSet.fromString(serverTokenResponse.scope) : new ScopeSet(requestScopes || []);\r\n\r\n            // Use timestamp calculated before request\r\n            const tokenExpirationSeconds = reqTimestamp + (serverTokenResponse.expires_in || 0);\r\n            const extendedTokenExpirationSeconds = tokenExpirationSeconds + (serverTokenResponse.ext_expires_in || 0);\r\n\r\n            // non AAD scenarios can have empty realm\r\n            cachedAccessToken = AccessTokenEntity.createAccessTokenEntity(\r\n                this.homeAccountIdentifier,\r\n                env,\r\n                serverTokenResponse.access_token || Constants.EMPTY_STRING,\r\n                this.clientId,\r\n                idTokenObj ? idTokenObj.claims.tid || Constants.EMPTY_STRING : authority.tenant,\r\n                responseScopes.printScopes(),\r\n                tokenExpirationSeconds,\r\n                extendedTokenExpirationSeconds,\r\n                serverTokenResponse.token_type,\r\n                oboAssertion\r\n            );\r\n        }\r\n\r\n        // refreshToken\r\n        let cachedRefreshToken: RefreshTokenEntity | null = null;\r\n        if (!StringUtils.isEmpty(serverTokenResponse.refresh_token)) {\r\n            cachedRefreshToken = RefreshTokenEntity.createRefreshTokenEntity(\r\n                this.homeAccountIdentifier,\r\n                env,\r\n                serverTokenResponse.refresh_token || Constants.EMPTY_STRING,\r\n                this.clientId,\r\n                serverTokenResponse.foci,\r\n                oboAssertion\r\n            );\r\n        }\r\n\r\n        // appMetadata\r\n        let cachedAppMetadata: AppMetadataEntity | null = null;\r\n        if (!StringUtils.isEmpty(serverTokenResponse.foci)) {\r\n            cachedAppMetadata = AppMetadataEntity.createAppMetadataEntity(this.clientId, env, serverTokenResponse.foci);\r\n        }\r\n\r\n        return new CacheRecord(cachedAccount, cachedIdToken, cachedAccessToken, cachedRefreshToken, cachedAppMetadata);\r\n    }\r\n\r\n    /**\r\n     * Generate Account\r\n     * @param serverTokenResponse\r\n     * @param idToken\r\n     * @param authority\r\n     */\r\n    private generateAccountEntity(serverTokenResponse: ServerAuthorizationTokenResponse, idToken: AuthToken, authority: Authority, oboAssertion?: string, authCodePayload?: AuthorizationCodePayload): AccountEntity {\r\n        const authorityType = authority.authorityType;\r\n        const cloudGraphHostName = authCodePayload ? authCodePayload.cloud_graph_host_name : \"\";\r\n        const msGraphhost = authCodePayload ? authCodePayload.msgraph_host : \"\";\r\n\r\n        // ADFS does not require client_info in the response\r\n        if (authorityType === AuthorityType.Adfs) {\r\n            this.logger.verbose(\"Authority type is ADFS, creating ADFS account\");\r\n            return AccountEntity.createGenericAccount(authority, this.homeAccountIdentifier, idToken, oboAssertion, cloudGraphHostName, msGraphhost);\r\n        }\r\n\r\n        // This fallback applies to B2C as well as they fall under an AAD account type.\r\n        if (StringUtils.isEmpty(serverTokenResponse.client_info) && authority.protocolMode === \"AAD\") {\r\n            throw ClientAuthError.createClientInfoEmptyError();\r\n        }\r\n\r\n        return serverTokenResponse.client_info ?\r\n            AccountEntity.createAccount(serverTokenResponse.client_info, this.homeAccountIdentifier, authority, idToken, oboAssertion, cloudGraphHostName, msGraphhost) :\r\n            AccountEntity.createGenericAccount(authority, this.homeAccountIdentifier, idToken, oboAssertion, cloudGraphHostName, msGraphhost);\r\n    }\r\n\r\n    /**\r\n     * Creates an @AuthenticationResult from @CacheRecord , @IdToken , and a boolean that states whether or not the result is from cache.\r\n     *\r\n     * Optionally takes a state string that is set as-is in the response.\r\n     *\r\n     * @param cacheRecord\r\n     * @param idTokenObj\r\n     * @param fromTokenCache\r\n     * @param stateString\r\n     */\r\n    static async generateAuthenticationResult(\r\n        cryptoObj: ICrypto, \r\n        authority: Authority,\r\n        cacheRecord: CacheRecord, \r\n        fromTokenCache: boolean, \r\n        idTokenObj?: AuthToken,\r\n        requestState?: RequestStateObject,\r\n        resourceRequestMethod?: string, \r\n        resourceRequestUri?: string): Promise<AuthenticationResult> {\r\n        let accessToken: string = \"\";\r\n        let responseScopes: Array<string> = [];\r\n        let expiresOn: Date | null = null;\r\n        let extExpiresOn: Date | undefined;\r\n        let familyId: string = Constants.EMPTY_STRING;\r\n        if (cacheRecord.accessToken) {\r\n            if (cacheRecord.accessToken.tokenType === AuthenticationScheme.POP) {\r\n                const popTokenGenerator: PopTokenGenerator = new PopTokenGenerator(cryptoObj);\r\n\r\n                if (!resourceRequestMethod || !resourceRequestUri) {\r\n                    throw ClientConfigurationError.createResourceRequestParametersRequiredError();\r\n                }\r\n                accessToken = await popTokenGenerator.signPopToken(cacheRecord.accessToken.secret, resourceRequestMethod, resourceRequestUri);\r\n            } else {\r\n                accessToken = cacheRecord.accessToken.secret;\r\n            }\r\n            responseScopes = ScopeSet.fromString(cacheRecord.accessToken.target).asArray();\r\n            expiresOn = new Date(Number(cacheRecord.accessToken.expiresOn) * 1000);\r\n            extExpiresOn = new Date(Number(cacheRecord.accessToken.extendedExpiresOn) * 1000);\r\n        }\r\n\r\n        if (cacheRecord.appMetadata) {\r\n            familyId = cacheRecord.appMetadata.familyId === THE_FAMILY_ID ? THE_FAMILY_ID : Constants.EMPTY_STRING;\r\n        }\r\n        const uid = idTokenObj?.claims.oid || idTokenObj?.claims.sub || Constants.EMPTY_STRING;\r\n        const tid = idTokenObj?.claims.tid || Constants.EMPTY_STRING;\r\n\r\n        return {\r\n            authority: authority.canonicalAuthority,\r\n            uniqueId: uid,\r\n            tenantId: tid,\r\n            scopes: responseScopes,\r\n            account: cacheRecord.account ? cacheRecord.account.getAccountInfo() : null,\r\n            idToken: idTokenObj ? idTokenObj.rawToken : Constants.EMPTY_STRING,\r\n            idTokenClaims: idTokenObj ? idTokenObj.claims : {},\r\n            accessToken: accessToken,\r\n            fromCache: fromTokenCache,\r\n            expiresOn: expiresOn,\r\n            extExpiresOn: extExpiresOn,\r\n            familyId: familyId,\r\n            tokenType: cacheRecord.accessToken?.tokenType || Constants.EMPTY_STRING,\r\n            state: requestState ? requestState.userRequestState : Constants.EMPTY_STRING,\r\n            cloudGraphHostName: cacheRecord.account?.cloudGraphHostName || Constants.EMPTY_STRING,\r\n            msGraphHost: cacheRecord.account?.msGraphHost || Constants.EMPTY_STRING\r\n        };\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { BaseClient } from \"./BaseClient\";\r\nimport { CommonAuthorizationUrlRequest } from \"../request/CommonAuthorizationUrlRequest\";\r\nimport { CommonAuthorizationCodeRequest } from \"../request/CommonAuthorizationCodeRequest\";\r\nimport { Authority } from \"../authority/Authority\";\r\nimport { RequestParameterBuilder } from \"../request/RequestParameterBuilder\";\r\nimport { GrantType, AuthenticationScheme } from \"../utils/Constants\";\r\nimport { ClientConfiguration } from \"../config/ClientConfiguration\";\r\nimport { ServerAuthorizationTokenResponse } from \"../response/ServerAuthorizationTokenResponse\";\r\nimport { NetworkResponse } from \"../network/NetworkManager\";\r\nimport { ResponseHandler } from \"../response/ResponseHandler\";\r\nimport { AuthenticationResult } from \"../response/AuthenticationResult\";\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\nimport { UrlString } from \"../url/UrlString\";\r\nimport { ServerAuthorizationCodeResponse } from \"../response/ServerAuthorizationCodeResponse\";\r\nimport { AccountEntity } from \"../cache/entities/AccountEntity\";\r\nimport { CommonEndSessionRequest } from \"../request/CommonEndSessionRequest\";\r\nimport { ClientConfigurationError } from \"../error/ClientConfigurationError\";\r\nimport { PopTokenGenerator } from \"../crypto/PopTokenGenerator\";\r\nimport { RequestThumbprint } from \"../network/RequestThumbprint\";\r\nimport { AuthorizationCodePayload } from \"../response/AuthorizationCodePayload\";\r\nimport { TimeUtils } from \"../utils/TimeUtils\";\r\n\r\n/**\r\n * Oauth2.0 Authorization Code client\r\n */\r\nexport class AuthorizationCodeClient extends BaseClient {\r\n\r\n    constructor(configuration: ClientConfiguration) {\r\n        super(configuration);\r\n    }\r\n\r\n    /**\r\n     * Creates the URL of the authorization request letting the user input credentials and consent to the\r\n     * application. The URL target the /authorize endpoint of the authority configured in the\r\n     * application object.\r\n     *\r\n     * Once the user inputs their credentials and consents, the authority will send a response to the redirect URI\r\n     * sent in the request and should contain an authorization code, which can then be used to acquire tokens via\r\n     * acquireToken(AuthorizationCodeRequest)\r\n     * @param request\r\n     */\r\n    async getAuthCodeUrl(request: CommonAuthorizationUrlRequest): Promise<string> {\r\n        const queryString = this.createAuthCodeUrlQueryString(request);\r\n        return `${this.authority.authorizationEndpoint}?${queryString}`;\r\n    }\r\n\r\n    /**\r\n     * API to acquire a token in exchange of 'authorization_code` acquired by the user in the first leg of the\r\n     * authorization_code_grant\r\n     * @param request\r\n     */\r\n    async acquireToken(request: CommonAuthorizationCodeRequest, authCodePayload?: AuthorizationCodePayload): Promise<AuthenticationResult> {\r\n        this.logger.info(\"in acquireToken call\");\r\n        if (!request || StringUtils.isEmpty(request.code)) {\r\n            throw ClientAuthError.createTokenRequestCannotBeMadeError();\r\n        }\r\n\r\n        const reqTimestamp = TimeUtils.nowSeconds();\r\n        const response = await this.executeTokenRequest(this.authority, request);\r\n\r\n        const responseHandler = new ResponseHandler(\r\n            this.config.authOptions.clientId,\r\n            this.cacheManager,\r\n            this.cryptoUtils,\r\n            this.logger,\r\n            this.config.serializableCache,\r\n            this.config.persistencePlugin\r\n        );\r\n\r\n        // Validate response. This function throws a server error if an error is returned by the server.\r\n        responseHandler.validateTokenResponse(response.body);\r\n        return await responseHandler.handleServerTokenResponse(response.body, this.authority, reqTimestamp, request.resourceRequestMethod, request.resourceRequestUri, authCodePayload);\r\n    }\r\n\r\n    /**\r\n     * Handles the hash fragment response from public client code request. Returns a code response used by\r\n     * the client to exchange for a token in acquireToken.\r\n     * @param hashFragment\r\n     */\r\n    handleFragmentResponse(hashFragment: string, cachedState: string): AuthorizationCodePayload {\r\n        // Handle responses.\r\n        const responseHandler = new ResponseHandler(this.config.authOptions.clientId, this.cacheManager, this.cryptoUtils, this.logger, null, null);\r\n\r\n        // Deserialize hash fragment response parameters.\r\n        const hashUrlString = new UrlString(hashFragment);\r\n        // Deserialize hash fragment response parameters.\r\n        const serverParams: ServerAuthorizationCodeResponse = UrlString.getDeserializedHash(hashUrlString.getHash());\r\n\r\n        // Get code response\r\n        responseHandler.validateServerAuthorizationCodeResponse(serverParams, cachedState, this.cryptoUtils);\r\n\r\n        // throw when there is no auth code in the response\r\n        if (!serverParams.code) {\r\n            throw ClientAuthError.createNoAuthCodeInServerResponseError();\r\n        }\r\n\r\n        return {\r\n            ...serverParams,\r\n            // Code param is optional in ServerAuthorizationCodeResponse but required in AuthorizationCodePaylod\r\n            code: serverParams.code\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Use to log out the current user, and redirect the user to the postLogoutRedirectUri.\r\n     * Default behaviour is to redirect the user to `window.location.href`.\r\n     * @param authorityUri\r\n     */\r\n    getLogoutUri(logoutRequest: CommonEndSessionRequest): string {\r\n        // Throw error if logoutRequest is null/undefined\r\n        if (!logoutRequest) {\r\n            throw ClientConfigurationError.createEmptyLogoutRequestError();\r\n        }\r\n\r\n        if (logoutRequest.account) {\r\n            // Clear given account.\r\n            this.cacheManager.removeAccount(AccountEntity.generateAccountCacheKey(logoutRequest.account));\r\n        } else {\r\n            // Clear all accounts and tokens\r\n            this.cacheManager.clear();\r\n        }\r\n\r\n        const queryString = this.createLogoutUrlQueryString(logoutRequest);\r\n\r\n        // Construct logout URI.\r\n        return StringUtils.isEmpty(queryString) ? this.authority.endSessionEndpoint : `${this.authority.endSessionEndpoint}?${queryString}`;\r\n    }\r\n\r\n    /**\r\n     * Executes POST request to token endpoint\r\n     * @param authority\r\n     * @param request\r\n     */\r\n    private async executeTokenRequest(authority: Authority, request: CommonAuthorizationCodeRequest): Promise<NetworkResponse<ServerAuthorizationTokenResponse>> {\r\n        const thumbprint: RequestThumbprint = {\r\n            clientId: this.config.authOptions.clientId,\r\n            authority: authority.canonicalAuthority,\r\n            scopes: request.scopes\r\n        };\r\n\r\n        const requestBody = await this.createTokenRequestBody(request);\r\n        const headers: Record<string, string> = this.createDefaultTokenRequestHeaders();\r\n\r\n        return this.executePostToTokenEndpoint(authority.tokenEndpoint, requestBody, headers, thumbprint);\r\n    }\r\n\r\n    /**\r\n     * Generates a map for all the params to be sent to the service\r\n     * @param request\r\n     */\r\n    private async createTokenRequestBody(request: CommonAuthorizationCodeRequest): Promise<string> {\r\n        const parameterBuilder = new RequestParameterBuilder();\r\n\r\n        parameterBuilder.addClientId(this.config.authOptions.clientId);\r\n\r\n        // validate the redirectUri (to be a non null value)\r\n        parameterBuilder.addRedirectUri(request.redirectUri);\r\n\r\n        // Add scope array, parameter builder will add default scopes and dedupe\r\n        parameterBuilder.addScopes(request.scopes);\r\n\r\n        // add code: user set, not validated\r\n        parameterBuilder.addAuthorizationCode(request.code);\r\n\r\n        // add code_verifier if passed\r\n        if (request.codeVerifier) {\r\n            parameterBuilder.addCodeVerifier(request.codeVerifier);\r\n        }\r\n\r\n        if (this.config.clientCredentials.clientSecret) {\r\n            parameterBuilder.addClientSecret(this.config.clientCredentials.clientSecret);\r\n        }\r\n\r\n        if (this.config.clientCredentials.clientAssertion) {\r\n            const clientAssertion = this.config.clientCredentials.clientAssertion;\r\n            parameterBuilder.addClientAssertion(clientAssertion.assertion);\r\n            parameterBuilder.addClientAssertionType(clientAssertion.assertionType);\r\n        }\r\n\r\n        parameterBuilder.addGrantType(GrantType.AUTHORIZATION_CODE_GRANT);\r\n        parameterBuilder.addClientInfo();\r\n\r\n        if (request.authenticationScheme === AuthenticationScheme.POP && !!request.resourceRequestMethod && !!request.resourceRequestUri) {\r\n            const popTokenGenerator = new PopTokenGenerator(this.cryptoUtils);\r\n            const cnfString = await popTokenGenerator.generateCnf(request.resourceRequestMethod, request.resourceRequestUri);\r\n            parameterBuilder.addPopToken(cnfString);\r\n        }\r\n\r\n        const correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();\r\n        parameterBuilder.addCorrelationId(correlationId);\r\n\r\n        if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {\r\n            parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);\r\n        }\r\n\r\n        return parameterBuilder.createQueryString();\r\n    }\r\n\r\n    /**\r\n     * This API validates the `AuthorizationCodeUrlRequest` and creates a URL\r\n     * @param request\r\n     */\r\n    private createAuthCodeUrlQueryString(request: CommonAuthorizationUrlRequest): string {\r\n        const parameterBuilder = new RequestParameterBuilder();\r\n\r\n        parameterBuilder.addClientId(this.config.authOptions.clientId);\r\n\r\n        const requestScopes = [...request.scopes || [], ...request.extraScopesToConsent || []];\r\n        parameterBuilder.addScopes(requestScopes);\r\n\r\n        // validate the redirectUri (to be a non null value)\r\n        parameterBuilder.addRedirectUri(request.redirectUri);\r\n\r\n        // generate the correlationId if not set by the user and add\r\n        const correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();\r\n        parameterBuilder.addCorrelationId(correlationId);\r\n\r\n        // add response_mode. If not passed in it defaults to query.\r\n        parameterBuilder.addResponseMode(request.responseMode);\r\n\r\n        // add response_type = code\r\n        parameterBuilder.addResponseTypeCode();\r\n\r\n        // add library info parameters\r\n        parameterBuilder.addLibraryInfo(this.config.libraryInfo);\r\n\r\n        // add client_info=1\r\n        parameterBuilder.addClientInfo();\r\n\r\n        if (request.codeChallenge && request.codeChallengeMethod) {\r\n            parameterBuilder.addCodeChallengeParams(request.codeChallenge, request.codeChallengeMethod);\r\n        }\r\n\r\n        if (request.prompt) {\r\n            parameterBuilder.addPrompt(request.prompt);\r\n        }\r\n\r\n        if (request.domainHint) {\r\n            parameterBuilder.addDomainHint(request.domainHint);\r\n        }\r\n\r\n        // Add sid or loginHint with preference for sid -> loginHint -> username of AccountInfo object\r\n        if (request.sid) {\r\n            parameterBuilder.addSid(request.sid);\r\n        } else if (request.loginHint) {\r\n            parameterBuilder.addLoginHint(request.loginHint);\r\n        } else if (request.account && request.account.username) {\r\n            parameterBuilder.addLoginHint(request.account.username);\r\n        }\r\n\r\n        if (request.nonce) {\r\n            parameterBuilder.addNonce(request.nonce);\r\n        }\r\n\r\n        if (request.state) {\r\n            parameterBuilder.addState(request.state);\r\n        }\r\n\r\n        if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {\r\n            parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);\r\n        }\r\n\r\n        if (request.extraQueryParameters) {\r\n            parameterBuilder.addExtraQueryParameters(request.extraQueryParameters);\r\n        }\r\n\r\n        return parameterBuilder.createQueryString();\r\n    }\r\n\r\n    /**\r\n     * This API validates the `EndSessionRequest` and creates a URL\r\n     * @param request\r\n     */\r\n    private createLogoutUrlQueryString(request: CommonEndSessionRequest): string {\r\n        const parameterBuilder = new RequestParameterBuilder();\r\n\r\n        if (request.postLogoutRedirectUri) {\r\n            parameterBuilder.addPostLogoutRedirectUri(request.postLogoutRedirectUri);\r\n        }\r\n\r\n        if (request.correlationId) {\r\n            parameterBuilder.addCorrelationId(request.correlationId);\r\n        }\r\n\r\n        if (request.idTokenHint) {\r\n            parameterBuilder.addIdTokenHint(request.idTokenHint);\r\n        }\r\n\r\n        return parameterBuilder.createQueryString();\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { DeviceCodeResponse, ServerDeviceCodeResponse } from \"../response/DeviceCodeResponse\";\r\nimport { BaseClient } from \"./BaseClient\";\r\nimport { CommonDeviceCodeRequest } from \"../request/CommonDeviceCodeRequest\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\nimport { RequestParameterBuilder } from \"../request/RequestParameterBuilder\";\r\nimport { Constants, GrantType } from \"../utils/Constants\";\r\nimport { ClientConfiguration } from \"../config/ClientConfiguration\";\r\nimport { TimeUtils } from \"../utils/TimeUtils\";\r\nimport { ServerAuthorizationTokenResponse } from \"../response/ServerAuthorizationTokenResponse\";\r\nimport { ResponseHandler } from \"../response/ResponseHandler\";\r\nimport { AuthenticationResult } from \"../response/AuthenticationResult\";\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\nimport { RequestThumbprint } from \"../network/RequestThumbprint\";\r\n\r\n/**\r\n * OAuth2.0 Device code client\r\n */\r\nexport class DeviceCodeClient extends BaseClient {\r\n\r\n    constructor(configuration: ClientConfiguration) {\r\n        super(configuration);\r\n    }\r\n\r\n    /**\r\n     * Gets device code from device code endpoint, calls back to with device code response, and\r\n     * polls token endpoint to exchange device code for tokens\r\n     * @param request\r\n     */\r\n    public async acquireToken(request: CommonDeviceCodeRequest): Promise<AuthenticationResult | null> {\r\n        const deviceCodeResponse: DeviceCodeResponse = await this.getDeviceCode(request);\r\n        request.deviceCodeCallback(deviceCodeResponse);\r\n        const reqTimestamp = TimeUtils.nowSeconds();\r\n        const response: ServerAuthorizationTokenResponse = await this.acquireTokenWithDeviceCode(\r\n            request,\r\n            deviceCodeResponse);\r\n\r\n        const responseHandler = new ResponseHandler(\r\n            this.config.authOptions.clientId,\r\n            this.cacheManager,\r\n            this.cryptoUtils,\r\n            this.logger,\r\n            this.config.serializableCache,\r\n            this.config.persistencePlugin\r\n        );\r\n\r\n        // Validate response. This function throws a server error if an error is returned by the server.\r\n        responseHandler.validateTokenResponse(response);\r\n        return await responseHandler.handleServerTokenResponse(\r\n            response,\r\n            this.authority,\r\n            reqTimestamp,\r\n            request.resourceRequestMethod,\r\n            request.resourceRequestUri\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Creates device code request and executes http GET\r\n     * @param request\r\n     */\r\n    private async getDeviceCode(request: CommonDeviceCodeRequest): Promise<DeviceCodeResponse> {\r\n        const queryString = this.createQueryString(request);\r\n        const headers = this.createDefaultTokenRequestHeaders();\r\n        const thumbprint: RequestThumbprint = {\r\n            clientId: this.config.authOptions.clientId,\r\n            authority: request.authority,\r\n            scopes: request.scopes\r\n        };\r\n\r\n        return this.executePostRequestToDeviceCodeEndpoint(this.authority.deviceCodeEndpoint, queryString, headers, thumbprint);\r\n    }\r\n\r\n    /**\r\n     * Executes POST request to device code endpoint\r\n     * @param deviceCodeEndpoint\r\n     * @param queryString\r\n     * @param headers\r\n     */\r\n    private async executePostRequestToDeviceCodeEndpoint(\r\n        deviceCodeEndpoint: string,\r\n        queryString: string,\r\n        headers: Record<string, string>,\r\n        thumbprint: RequestThumbprint): Promise<DeviceCodeResponse> {\r\n\r\n        const {\r\n            body: {\r\n                user_code: userCode,\r\n                device_code: deviceCode,\r\n                verification_uri: verificationUri,\r\n                expires_in: expiresIn,\r\n                interval,\r\n                message\r\n            }\r\n        } = await this.networkManager.sendPostRequest<ServerDeviceCodeResponse>(\r\n            thumbprint,\r\n            deviceCodeEndpoint,\r\n            {\r\n                body: queryString,\r\n                headers: headers\r\n            });\r\n\r\n        return {\r\n            userCode,\r\n            deviceCode,\r\n            verificationUri,\r\n            expiresIn,\r\n            interval,\r\n            message\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Create device code endpoint query parameters and returns string\r\n     */\r\n    private createQueryString(request: CommonDeviceCodeRequest): string {\r\n\r\n        const parameterBuilder: RequestParameterBuilder = new RequestParameterBuilder();\r\n\r\n        parameterBuilder.addScopes(request.scopes);\r\n        parameterBuilder.addClientId(this.config.authOptions.clientId);\r\n\r\n        if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {\r\n            parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);\r\n        }\r\n\r\n        return parameterBuilder.createQueryString();\r\n    }\r\n\r\n    /**\r\n     * Creates token request with device code response and polls token endpoint at interval set by the device code\r\n     * response\r\n     * @param request\r\n     * @param deviceCodeResponse\r\n     */\r\n    private async acquireTokenWithDeviceCode(\r\n        request: CommonDeviceCodeRequest,\r\n        deviceCodeResponse: DeviceCodeResponse): Promise<ServerAuthorizationTokenResponse> {\r\n\r\n        const requestBody = this.createTokenRequestBody(request, deviceCodeResponse);\r\n        const headers: Record<string, string> = this.createDefaultTokenRequestHeaders();\r\n\r\n        const userSpecifiedTimeout = request.timeout ? TimeUtils.nowSeconds() + request.timeout : undefined;\r\n        const deviceCodeExpirationTime = TimeUtils.nowSeconds() + deviceCodeResponse.expiresIn;\r\n        const pollingIntervalMilli = deviceCodeResponse.interval * 1000;\r\n\r\n        /*\r\n         * Poll token endpoint while (device code is not expired AND operation has not been cancelled by\r\n         * setting CancellationToken.cancel = true). POST request is sent at interval set by pollingIntervalMilli\r\n         */\r\n        return new Promise<ServerAuthorizationTokenResponse>((resolve, reject) => {\r\n\r\n            const intervalId: ReturnType<typeof setTimeout> = setInterval(async () => {\r\n                try {\r\n                    if (request.cancel) {\r\n\r\n                        this.logger.error(\"Token request cancelled by setting DeviceCodeRequest.cancel = true\");\r\n                        clearInterval(intervalId);\r\n                        reject(ClientAuthError.createDeviceCodeCancelledError());\r\n\r\n                    } else if (userSpecifiedTimeout && userSpecifiedTimeout < deviceCodeExpirationTime && TimeUtils.nowSeconds() > userSpecifiedTimeout) {\r\n\r\n                        this.logger.error(`User defined timeout for device code polling reached. The timeout was set for ${userSpecifiedTimeout}`);\r\n                        clearInterval(intervalId);\r\n                        reject(ClientAuthError.createUserTimeoutReachedError());\r\n\r\n                    } else if (TimeUtils.nowSeconds() > deviceCodeExpirationTime) {\r\n\r\n                        if (userSpecifiedTimeout) {\r\n                            this.logger.verbose(`User specified timeout ignored as the device code has expired before the timeout elapsed. The user specified timeout was set for ${userSpecifiedTimeout}`);\r\n                        }\r\n\r\n                        this.logger.error(`Device code expired. Expiration time of device code was ${deviceCodeExpirationTime}`);\r\n                        clearInterval(intervalId);\r\n                        reject(ClientAuthError.createDeviceCodeExpiredError());\r\n\r\n                    } else {\r\n                        const thumbprint: RequestThumbprint = {\r\n                            clientId: this.config.authOptions.clientId,\r\n                            authority: request.authority,\r\n                            scopes: request.scopes\r\n                        };\r\n                        const response = await this.executePostToTokenEndpoint(\r\n                            this.authority.tokenEndpoint,\r\n                            requestBody,\r\n                            headers,\r\n                            thumbprint);\r\n\r\n                        if (response.body && response.body.error === Constants.AUTHORIZATION_PENDING) {\r\n                            // user authorization is pending. Sleep for polling interval and try again\r\n                            this.logger.info(response.body.error_description || \"no_error_description\");\r\n                        } else {\r\n                            clearInterval(intervalId);\r\n                            resolve(response.body);\r\n                        }\r\n                    }\r\n                } catch (error) {\r\n                    clearInterval(intervalId);\r\n                    reject(error);\r\n                }\r\n            }, pollingIntervalMilli);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Creates query parameters and converts to string.\r\n     * @param request\r\n     * @param deviceCodeResponse\r\n     */\r\n    private createTokenRequestBody(request: CommonDeviceCodeRequest, deviceCodeResponse: DeviceCodeResponse): string {\r\n\r\n        const requestParameters: RequestParameterBuilder = new RequestParameterBuilder();\r\n\r\n        requestParameters.addScopes(request.scopes);\r\n        requestParameters.addClientId(this.config.authOptions.clientId);\r\n        requestParameters.addGrantType(GrantType.DEVICE_CODE_GRANT);\r\n        requestParameters.addDeviceCode(deviceCodeResponse.deviceCode);\r\n        const correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();\r\n        requestParameters.addCorrelationId(correlationId);\r\n        requestParameters.addClientInfo();\r\n\r\n        if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {\r\n            requestParameters.addClaims(request.claims, this.config.authOptions.clientCapabilities);\r\n        }\r\n        return requestParameters.createQueryString();\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { ClientConfiguration } from \"../config/ClientConfiguration\";\r\nimport { BaseClient } from \"./BaseClient\";\r\nimport { CommonRefreshTokenRequest } from \"../request/CommonRefreshTokenRequest\";\r\nimport { Authority } from \"../authority/Authority\";\r\nimport { ServerAuthorizationTokenResponse } from \"../response/ServerAuthorizationTokenResponse\";\r\nimport { RequestParameterBuilder } from \"../request/RequestParameterBuilder\";\r\nimport { GrantType, AuthenticationScheme, Errors  } from \"../utils/Constants\";\r\nimport { ResponseHandler } from \"../response/ResponseHandler\";\r\nimport { AuthenticationResult } from \"../response/AuthenticationResult\";\r\nimport { PopTokenGenerator } from \"../crypto/PopTokenGenerator\";\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\nimport { RequestThumbprint } from \"../network/RequestThumbprint\";\r\nimport { NetworkResponse } from \"../network/NetworkManager\";\r\nimport { CommonSilentFlowRequest } from \"../request/CommonSilentFlowRequest\";\r\nimport { ClientConfigurationError } from \"../error/ClientConfigurationError\";\r\nimport { ClientAuthError, ClientAuthErrorMessage } from \"../error/ClientAuthError\";\r\nimport { ServerError } from \"../error/ServerError\";\r\nimport { TimeUtils } from \"../utils/TimeUtils\";\r\n\r\n/**\r\n * OAuth2.0 refresh token client\r\n */\r\nexport class RefreshTokenClient extends BaseClient {\r\n\r\n    constructor(configuration: ClientConfiguration) {\r\n        super(configuration);\r\n    }\r\n\r\n    public async acquireToken(request: CommonRefreshTokenRequest): Promise<AuthenticationResult>{\r\n        const reqTimestamp = TimeUtils.nowSeconds();\r\n        const response = await this.executeTokenRequest(request, this.authority);\r\n\r\n        const responseHandler = new ResponseHandler(\r\n            this.config.authOptions.clientId,\r\n            this.cacheManager,\r\n            this.cryptoUtils,\r\n            this.logger,\r\n            this.config.serializableCache,\r\n            this.config.persistencePlugin\r\n        );\r\n\r\n        responseHandler.validateTokenResponse(response.body);\r\n        return responseHandler.handleServerTokenResponse(\r\n            response.body,\r\n            this.authority,\r\n            reqTimestamp,\r\n            request.resourceRequestMethod,\r\n            request.resourceRequestUri,\r\n            undefined,\r\n            [],\r\n            undefined,\r\n            true\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Gets cached refresh token and attaches to request, then calls acquireToken API\r\n     * @param request\r\n     */\r\n    public async acquireTokenByRefreshToken(request: CommonSilentFlowRequest): Promise<AuthenticationResult> {\r\n        // Cannot renew token if no request object is given.\r\n        if (!request) {\r\n            throw ClientConfigurationError.createEmptyTokenRequestError();\r\n        }\r\n\r\n        // We currently do not support silent flow for account === null use cases; This will be revisited for confidential flow usecases\r\n        if (!request.account) {\r\n            throw ClientAuthError.createNoAccountInSilentRequestError();\r\n        }\r\n\r\n        // try checking if FOCI is enabled for the given application\r\n        const isFOCI = this.cacheManager.isAppMetadataFOCI(request.account.environment, this.config.authOptions.clientId);\r\n\r\n        // if the app is part of the family, retrive a Family refresh token if present and make a refreshTokenRequest\r\n        if (isFOCI) {\r\n            try {\r\n                return this.acquireTokenWithCachedRefreshToken(request, true);\r\n            }\r\n            catch (e) {\r\n                const noFamilyRTInCache = e instanceof ClientAuthError && e.errorCode === ClientAuthErrorMessage.noTokensFoundError.code;\r\n                const clientMismatchErrorWithFamilyRT = e instanceof ServerError && e.errorCode === Errors.INVALID_GRANT_ERROR && e.subError === Errors.CLIENT_MISMATCH_ERROR;\r\n\r\n                // if family Refresh Token (FRT) cache acquisition fails or if client_mismatch error is seen with FRT, reattempt with application Refresh Token (ART)\r\n                if (noFamilyRTInCache || clientMismatchErrorWithFamilyRT) {\r\n                    return this.acquireTokenWithCachedRefreshToken(request, false);\r\n                // throw in all other cases\r\n                } else {\r\n                    throw e;\r\n                }\r\n            }\r\n        }\r\n\r\n        // fall back to application refresh token acquisition\r\n        return this.acquireTokenWithCachedRefreshToken(request, false);\r\n    }\r\n\r\n    /**\r\n     * makes a network call to acquire tokens by exchanging RefreshToken available in userCache; throws if refresh token is not cached\r\n     * @param request\r\n     */\r\n    private async acquireTokenWithCachedRefreshToken(request: CommonSilentFlowRequest, foci: boolean) {\r\n        // fetches family RT or application RT based on FOCI value\r\n        const refreshToken = this.cacheManager.readRefreshTokenFromCache(this.config.authOptions.clientId, request.account, foci);\r\n\r\n        // no refresh Token\r\n        if (!refreshToken) {\r\n            throw ClientAuthError.createNoTokensFoundError();\r\n        }\r\n\r\n        const refreshTokenRequest: CommonRefreshTokenRequest = {\r\n            ...request,\r\n            refreshToken: refreshToken.secret,\r\n            authenticationScheme: AuthenticationScheme.BEARER\r\n        };\r\n\r\n        return this.acquireToken(refreshTokenRequest);\r\n    }\r\n\r\n    /**\r\n     * Constructs the network message and makes a NW call to the underlying secure token service\r\n     * @param request\r\n     * @param authority\r\n     */\r\n    private async executeTokenRequest(request: CommonRefreshTokenRequest, authority: Authority)\r\n        : Promise<NetworkResponse<ServerAuthorizationTokenResponse>> {\r\n\r\n        const requestBody = await this.createTokenRequestBody(request);\r\n        const headers: Record<string, string> = this.createDefaultTokenRequestHeaders();\r\n        const thumbprint: RequestThumbprint = {\r\n            clientId: this.config.authOptions.clientId,\r\n            authority: authority.canonicalAuthority,\r\n            scopes: request.scopes\r\n        };\r\n\r\n        return this.executePostToTokenEndpoint(authority.tokenEndpoint, requestBody, headers, thumbprint);\r\n    }\r\n\r\n    /**\r\n     * Helper function to create the token request body\r\n     * @param request\r\n     */\r\n    private async createTokenRequestBody(request: CommonRefreshTokenRequest): Promise<string> {\r\n        const parameterBuilder = new RequestParameterBuilder();\r\n\r\n        parameterBuilder.addClientId(this.config.authOptions.clientId);\r\n\r\n        parameterBuilder.addScopes(request.scopes);\r\n\r\n        parameterBuilder.addGrantType(GrantType.REFRESH_TOKEN_GRANT);\r\n\r\n        parameterBuilder.addClientInfo();\r\n\r\n        const correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();\r\n        parameterBuilder.addCorrelationId(correlationId);\r\n\r\n        parameterBuilder.addRefreshToken(request.refreshToken);\r\n\r\n        if (this.config.clientCredentials.clientSecret) {\r\n            parameterBuilder.addClientSecret(this.config.clientCredentials.clientSecret);\r\n        }\r\n\r\n        if (this.config.clientCredentials.clientAssertion) {\r\n            const clientAssertion = this.config.clientCredentials.clientAssertion;\r\n            parameterBuilder.addClientAssertion(clientAssertion.assertion);\r\n            parameterBuilder.addClientAssertionType(clientAssertion.assertionType);\r\n        }\r\n\r\n        if (request.authenticationScheme === AuthenticationScheme.POP) {\r\n            const popTokenGenerator = new PopTokenGenerator(this.cryptoUtils);\r\n            if (!request.resourceRequestMethod || !request.resourceRequestUri) {\r\n                throw ClientConfigurationError.createResourceRequestParametersRequiredError();\r\n            }\r\n\r\n            parameterBuilder.addPopToken(await popTokenGenerator.generateCnf(request.resourceRequestMethod, request.resourceRequestUri));\r\n        }\r\n\r\n        if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {\r\n            parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);\r\n        }\r\n\r\n        return parameterBuilder.createQueryString();\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { ClientConfiguration } from \"../config/ClientConfiguration\";\r\nimport { BaseClient } from \"./BaseClient\";\r\nimport { Authority } from \"../authority/Authority\";\r\nimport { RequestParameterBuilder } from \"../request/RequestParameterBuilder\";\r\nimport { ScopeSet } from \"../request/ScopeSet\";\r\nimport { GrantType , CredentialType } from \"../utils/Constants\";\r\nimport { ResponseHandler } from \"../response/ResponseHandler\";\r\nimport { AuthenticationResult } from \"../response/AuthenticationResult\";\r\nimport { CommonClientCredentialRequest } from \"../request/CommonClientCredentialRequest\";\r\nimport { CredentialFilter, CredentialCache } from \"../cache/utils/CacheTypes\";\r\nimport { AccessTokenEntity } from \"../cache/entities/AccessTokenEntity\";\r\nimport { TimeUtils } from \"../utils/TimeUtils\";\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\nimport { RequestThumbprint } from \"../network/RequestThumbprint\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\n\r\n/**\r\n * OAuth2.0 client credential grant\r\n */\r\nexport class ClientCredentialClient extends BaseClient {\r\n\r\n    private scopeSet: ScopeSet;\r\n\r\n    constructor(configuration: ClientConfiguration) {\r\n        super(configuration);\r\n    }\r\n\r\n    /**\r\n     * Public API to acquire a token with ClientCredential Flow for Confidential clients\r\n     * @param request\r\n     */\r\n    public async acquireToken(request: CommonClientCredentialRequest): Promise<AuthenticationResult | null> {\r\n\r\n        this.scopeSet = new ScopeSet(request.scopes || []);\r\n\r\n        if (request.skipCache) {\r\n            return await this.executeTokenRequest(request, this.authority);\r\n        }\r\n\r\n        const cachedAuthenticationResult = await this.getCachedAuthenticationResult();\r\n        if (cachedAuthenticationResult) {\r\n            return cachedAuthenticationResult;\r\n        } else {\r\n            return await this.executeTokenRequest(request, this.authority);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * looks up cache if the tokens are cached already\r\n     */\r\n    private async getCachedAuthenticationResult(): Promise<AuthenticationResult | null> {\r\n        const cachedAccessToken = this.readAccessTokenFromCache();\r\n        if (!cachedAccessToken ||\r\n            TimeUtils.isTokenExpired(cachedAccessToken.expiresOn, this.config.systemOptions.tokenRenewalOffsetSeconds)) {\r\n            return null;\r\n        }\r\n\r\n        return await ResponseHandler.generateAuthenticationResult(\r\n            this.cryptoUtils,\r\n            this.authority,\r\n            {\r\n                account: null,\r\n                idToken: null,\r\n                accessToken: cachedAccessToken,\r\n                refreshToken: null,\r\n                appMetadata: null\r\n            },\r\n            true\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Reads access token from the cache\r\n     * TODO: Move this call to cacheManager instead\r\n     */\r\n    private readAccessTokenFromCache(): AccessTokenEntity | null {\r\n        const accessTokenFilter: CredentialFilter = {\r\n            homeAccountId: \"\",\r\n            environment: this.authority.canonicalAuthorityUrlComponents.HostNameAndPort,\r\n            credentialType: CredentialType.ACCESS_TOKEN,\r\n            clientId: this.config.authOptions.clientId,\r\n            realm: this.authority.tenant,\r\n            target: this.scopeSet.printScopesLowerCase()\r\n        };\r\n        const credentialCache: CredentialCache = this.cacheManager.getCredentialsFilteredBy(accessTokenFilter);\r\n        const accessTokens = Object.keys(credentialCache.accessTokens).map(key => credentialCache.accessTokens[key]);\r\n        if (accessTokens.length < 1) {\r\n            return null;\r\n        } else if (accessTokens.length > 1) {\r\n            throw ClientAuthError.createMultipleMatchingTokensInCacheError();\r\n        }\r\n        return accessTokens[0] as AccessTokenEntity;\r\n    }\r\n\r\n    /**\r\n     * Makes a network call to request the token from the service\r\n     * @param request\r\n     * @param authority\r\n     */\r\n    private async executeTokenRequest(request: CommonClientCredentialRequest, authority: Authority)\r\n        : Promise<AuthenticationResult | null> {\r\n\r\n        const requestBody = this.createTokenRequestBody(request);\r\n        const headers: Record<string, string> = this.createDefaultTokenRequestHeaders();\r\n        const thumbprint: RequestThumbprint = {\r\n            clientId: this.config.authOptions.clientId,\r\n            authority: request.authority,\r\n            scopes: request.scopes\r\n        };\r\n\r\n        const reqTimestamp = TimeUtils.nowSeconds();\r\n        const response = await this.executePostToTokenEndpoint(authority.tokenEndpoint, requestBody, headers, thumbprint);\r\n\r\n        const responseHandler = new ResponseHandler(\r\n            this.config.authOptions.clientId,\r\n            this.cacheManager,\r\n            this.cryptoUtils,\r\n            this.logger,\r\n            this.config.serializableCache,\r\n            this.config.persistencePlugin\r\n        );\r\n\r\n        responseHandler.validateTokenResponse(response.body);\r\n        const tokenResponse = await responseHandler.handleServerTokenResponse(\r\n            response.body,\r\n            this.authority,\r\n            reqTimestamp,\r\n            request.resourceRequestMethod,\r\n            request.resourceRequestUri,\r\n            undefined,\r\n            request.scopes\r\n        );\r\n\r\n        return tokenResponse;\r\n    }\r\n\r\n    /**\r\n     * generate the request to the server in the acceptable format\r\n     * @param request\r\n     */\r\n    private createTokenRequestBody(request: CommonClientCredentialRequest): string {\r\n        const parameterBuilder = new RequestParameterBuilder();\r\n\r\n        parameterBuilder.addClientId(this.config.authOptions.clientId);\r\n\r\n        parameterBuilder.addScopes(request.scopes, false);\r\n\r\n        parameterBuilder.addGrantType(GrantType.CLIENT_CREDENTIALS_GRANT);\r\n\r\n        const correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();\r\n        parameterBuilder.addCorrelationId(correlationId);\r\n\r\n        if (this.config.clientCredentials.clientSecret) {\r\n            parameterBuilder.addClientSecret(this.config.clientCredentials.clientSecret);\r\n        }\r\n\r\n        if (this.config.clientCredentials.clientAssertion) {\r\n            const clientAssertion = this.config.clientCredentials.clientAssertion;\r\n            parameterBuilder.addClientAssertion(clientAssertion.assertion);\r\n            parameterBuilder.addClientAssertionType(clientAssertion.assertionType);\r\n        }\r\n\r\n        if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {\r\n            parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);\r\n        }\r\n\r\n        return parameterBuilder.createQueryString();\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { ClientConfiguration } from \"../config/ClientConfiguration\";\r\nimport { BaseClient } from \"./BaseClient\";\r\nimport { Authority } from \"../authority/Authority\";\r\nimport { RequestParameterBuilder } from \"../request/RequestParameterBuilder\";\r\nimport { ScopeSet } from \"../request/ScopeSet\";\r\nimport { GrantType, AADServerParamKeys , CredentialType, Constants } from \"../utils/Constants\";\r\nimport { ResponseHandler } from \"../response/ResponseHandler\";\r\nimport { AuthenticationResult } from \"../response/AuthenticationResult\";\r\nimport { CommonOnBehalfOfRequest } from \"../request/CommonOnBehalfOfRequest\";\r\nimport { TimeUtils } from \"../utils/TimeUtils\";\r\nimport { CredentialFilter, CredentialCache } from \"../cache/utils/CacheTypes\";\r\nimport { AccessTokenEntity } from \"../cache/entities/AccessTokenEntity\";\r\nimport { IdTokenEntity } from \"../cache/entities/IdTokenEntity\";\r\nimport { AccountEntity } from \"../cache/entities/AccountEntity\";\r\nimport { AuthToken } from \"../account/AuthToken\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\nimport { RequestThumbprint } from \"../network/RequestThumbprint\";\r\nimport { AccountInfo } from \"../account/AccountInfo\";\r\n\r\n/**\r\n * On-Behalf-Of client\r\n */\r\nexport class OnBehalfOfClient extends BaseClient {\r\n\r\n    private scopeSet: ScopeSet;\r\n\r\n    constructor(configuration: ClientConfiguration) {\r\n        super(configuration);\r\n    }\r\n\r\n    /**\r\n     * Public API to acquire tokens with on behalf of flow\r\n     * @param request\r\n     */\r\n    public async acquireToken(request: CommonOnBehalfOfRequest): Promise<AuthenticationResult | null> {\r\n        this.scopeSet = new ScopeSet(request.scopes || []);\r\n\r\n        if (request.skipCache) {\r\n            return await this.executeTokenRequest(request, this.authority);\r\n        }\r\n\r\n        const cachedAuthenticationResult = await this.getCachedAuthenticationResult(request);\r\n        if (cachedAuthenticationResult) {\r\n            return cachedAuthenticationResult;\r\n        } else {\r\n            return await this.executeTokenRequest(request, this.authority);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * look up cache for tokens\r\n     * @param request\r\n     */\r\n    private async getCachedAuthenticationResult(request: CommonOnBehalfOfRequest): Promise<AuthenticationResult | null> {\r\n        const cachedAccessToken = this.readAccessTokenFromCache(request);\r\n        if (!cachedAccessToken ||\r\n            TimeUtils.isTokenExpired(cachedAccessToken.expiresOn, this.config.systemOptions.tokenRenewalOffsetSeconds)) {\r\n            return null;\r\n        }\r\n\r\n        const cachedIdToken = this.readIdTokenFromCache(request);\r\n        let idTokenObject: AuthToken | undefined;\r\n        let cachedAccount: AccountEntity | null = null;\r\n        if (cachedIdToken) {\r\n            idTokenObject = new AuthToken(cachedIdToken.secret, this.config.cryptoInterface);\r\n            const localAccountId = idTokenObject.claims.oid ? idTokenObject.claims.oid : idTokenObject.claims.sub;\r\n            const accountInfo: AccountInfo = {\r\n                homeAccountId: cachedIdToken.homeAccountId,\r\n                environment: cachedIdToken.environment,\r\n                tenantId: cachedIdToken.realm,\r\n                username: Constants.EMPTY_STRING,\r\n                localAccountId: localAccountId || \"\"\r\n            };\r\n\r\n            cachedAccount = this.readAccountFromCache(accountInfo);\r\n        }\r\n\r\n        return await ResponseHandler.generateAuthenticationResult(\r\n            this.cryptoUtils,\r\n            this.authority,\r\n            {\r\n                account: cachedAccount,\r\n                accessToken: cachedAccessToken,\r\n                idToken: cachedIdToken,\r\n                refreshToken: null,\r\n                appMetadata: null\r\n            }, true, idTokenObject);\r\n    }\r\n\r\n    /**\r\n     * read access token from cache TODO: CacheManager API should be used here\r\n     * @param request\r\n     */\r\n    private readAccessTokenFromCache(request: CommonOnBehalfOfRequest): AccessTokenEntity | null {\r\n        const accessTokenFilter: CredentialFilter = {\r\n            environment: this.authority.canonicalAuthorityUrlComponents.HostNameAndPort,\r\n            credentialType: CredentialType.ACCESS_TOKEN,\r\n            clientId: this.config.authOptions.clientId,\r\n            realm: this.authority.tenant,\r\n            target: this.scopeSet.printScopesLowerCase(),\r\n            oboAssertion: request.oboAssertion\r\n        };\r\n\r\n        const credentialCache: CredentialCache = this.cacheManager.getCredentialsFilteredBy(accessTokenFilter);\r\n        const accessTokens = Object.keys(credentialCache.accessTokens).map(key => credentialCache.accessTokens[key]);\r\n\r\n        const numAccessTokens = accessTokens.length;\r\n        if (numAccessTokens < 1) {\r\n            return null;\r\n        } else if (numAccessTokens > 1) {\r\n            throw ClientAuthError.createMultipleMatchingTokensInCacheError();\r\n        }\r\n        return accessTokens[0] as AccessTokenEntity;\r\n    }\r\n\r\n    /**\r\n     * read idtoken from cache TODO: CacheManager API should be used here instead\r\n     * @param request\r\n     */\r\n    private readIdTokenFromCache(request: CommonOnBehalfOfRequest): IdTokenEntity | null {\r\n        const idTokenFilter: CredentialFilter = {\r\n            environment: this.authority.canonicalAuthorityUrlComponents.HostNameAndPort,\r\n            credentialType: CredentialType.ID_TOKEN,\r\n            clientId: this.config.authOptions.clientId,\r\n            realm: this.authority.tenant,\r\n            oboAssertion: request.oboAssertion\r\n        };\r\n\r\n        const credentialCache: CredentialCache = this.cacheManager.getCredentialsFilteredBy(idTokenFilter);\r\n        const idTokens = Object.keys(credentialCache.idTokens).map(key => credentialCache.idTokens[key]);\r\n        // When acquiring a token on behalf of an application, there might not be an id token in the cache\r\n        if (idTokens.length < 1) {\r\n            return null;\r\n        }\r\n        return idTokens[0] as IdTokenEntity;\r\n    }\r\n\r\n    /**\r\n     * read account from cache, TODO: CacheManager API should be used here instead\r\n     * @param account\r\n     */\r\n    private readAccountFromCache(account: AccountInfo): AccountEntity | null {\r\n        return this.cacheManager.readAccountFromCache(account);\r\n    }\r\n\r\n    /**\r\n     * Make a network call to the server requesting credentials\r\n     * @param request\r\n     * @param authority\r\n     */\r\n    private async executeTokenRequest(request: CommonOnBehalfOfRequest, authority: Authority)\r\n        : Promise<AuthenticationResult | null> {\r\n\r\n        const requestBody = this.createTokenRequestBody(request);\r\n        const headers: Record<string, string> = this.createDefaultTokenRequestHeaders();\r\n        const thumbprint: RequestThumbprint = {\r\n            clientId: this.config.authOptions.clientId,\r\n            authority: request.authority,\r\n            scopes: request.scopes\r\n        };\r\n\r\n        const reqTimestamp = TimeUtils.nowSeconds();\r\n        const response = await this.executePostToTokenEndpoint(authority.tokenEndpoint, requestBody, headers, thumbprint);\r\n\r\n        const responseHandler = new ResponseHandler(\r\n            this.config.authOptions.clientId,\r\n            this.cacheManager,\r\n            this.cryptoUtils,\r\n            this.logger,\r\n            this.config.serializableCache,\r\n            this.config.persistencePlugin\r\n        );\r\n\r\n        responseHandler.validateTokenResponse(response.body);\r\n        const tokenResponse = await responseHandler.handleServerTokenResponse(\r\n            response.body,\r\n            this.authority,\r\n            reqTimestamp,\r\n            request.resourceRequestMethod,\r\n            request.resourceRequestUri,\r\n            undefined,\r\n            request.scopes,\r\n            request.oboAssertion\r\n        );\r\n\r\n        return tokenResponse;\r\n    }\r\n\r\n    /**\r\n     * generate a server request in accepable format\r\n     * @param request\r\n     */\r\n    private createTokenRequestBody(request: CommonOnBehalfOfRequest): string {\r\n        const parameterBuilder = new RequestParameterBuilder();\r\n\r\n        parameterBuilder.addClientId(this.config.authOptions.clientId);\r\n\r\n        parameterBuilder.addScopes(request.scopes);\r\n\r\n        parameterBuilder.addGrantType(GrantType.JWT_BEARER);\r\n\r\n        parameterBuilder.addClientInfo();\r\n\r\n        const correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();\r\n        parameterBuilder.addCorrelationId(correlationId);\r\n\r\n        parameterBuilder.addRequestTokenUse(AADServerParamKeys.ON_BEHALF_OF);\r\n\r\n        parameterBuilder.addOboAssertion(request.oboAssertion);\r\n\r\n        if (this.config.clientCredentials.clientSecret) {\r\n            parameterBuilder.addClientSecret(this.config.clientCredentials.clientSecret);\r\n        }\r\n\r\n        if (this.config.clientCredentials.clientAssertion) {\r\n            const clientAssertion = this.config.clientCredentials.clientAssertion;\r\n            parameterBuilder.addClientAssertion(clientAssertion.assertion);\r\n            parameterBuilder.addClientAssertionType(clientAssertion.assertionType);\r\n        }\r\n\r\n        return parameterBuilder.createQueryString();\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { BaseClient } from \"./BaseClient\";\r\nimport { ClientConfiguration } from \"../config/ClientConfiguration\";\r\nimport { CommonSilentFlowRequest } from \"../request/CommonSilentFlowRequest\";\r\nimport { AuthenticationResult } from \"../response/AuthenticationResult\";\r\nimport { AccessTokenEntity } from \"../cache/entities/AccessTokenEntity\";\r\nimport { ScopeSet } from \"../request/ScopeSet\";\r\nimport { AuthToken } from \"../account/AuthToken\";\r\nimport { TimeUtils } from \"../utils/TimeUtils\";\r\nimport { RefreshTokenClient } from \"./RefreshTokenClient\";\r\nimport { ClientAuthError, ClientAuthErrorMessage } from \"../error/ClientAuthError\";\r\nimport { ClientConfigurationError } from \"../error/ClientConfigurationError\";\r\nimport { ResponseHandler } from \"../response/ResponseHandler\";\r\nimport { CacheRecord } from \"../cache/entities/CacheRecord\";\r\n\r\nexport class SilentFlowClient extends BaseClient {\r\n\r\n    constructor(configuration: ClientConfiguration) {\r\n        super(configuration);\r\n    }\r\n\r\n    /**\r\n     * Retrieves a token from cache if it is still valid, or uses the cached refresh token to renew\r\n     * the given token and returns the renewed token\r\n     * @param request\r\n     */\r\n    async acquireToken(request: CommonSilentFlowRequest): Promise<AuthenticationResult> {\r\n        try {\r\n            return await this.acquireCachedToken(request);\r\n        } catch (e) {\r\n            if (e instanceof ClientAuthError && e.errorCode === ClientAuthErrorMessage.tokenRefreshRequired.code) {\r\n                const refreshTokenClient = new RefreshTokenClient(this.config);\r\n                return refreshTokenClient.acquireTokenByRefreshToken(request);\r\n            } else {\r\n                throw e;\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Retrieves token from cache or throws an error if it must be refreshed.\r\n     * @param request\r\n     */\r\n    async acquireCachedToken(request: CommonSilentFlowRequest): Promise<AuthenticationResult> {\r\n        // Cannot renew token if no request object is given.\r\n        if (!request) {\r\n            throw ClientConfigurationError.createEmptyTokenRequestError();\r\n        }\r\n\r\n        // We currently do not support silent flow for account === null use cases; This will be revisited for confidential flow usecases\r\n        if (!request.account) {\r\n            throw ClientAuthError.createNoAccountInSilentRequestError();\r\n        }\r\n\r\n        const requestScopes = new ScopeSet(request.scopes || []);\r\n        const environment = request.authority || this.authority.getPreferredCache();\r\n        const cacheRecord = this.cacheManager.readCacheRecord(request.account, this.config.authOptions.clientId, requestScopes, environment);\r\n\r\n        if (this.isRefreshRequired(request, cacheRecord.accessToken)) {\r\n            throw ClientAuthError.createRefreshRequiredError();\r\n        } else {\r\n            if (this.config.serverTelemetryManager) {\r\n                this.config.serverTelemetryManager.incrementCacheHits();\r\n            }\r\n            return await this.generateResultFromCacheRecord(cacheRecord, request.resourceRequestMethod, request.resourceRequestUri);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Helper function to build response object from the CacheRecord\r\n     * @param cacheRecord\r\n     */\r\n    private async generateResultFromCacheRecord(cacheRecord: CacheRecord, resourceRequestMethod?: string, resourceRequestUri?: string): Promise<AuthenticationResult> {\r\n        let idTokenObj: AuthToken | undefined;\r\n        if (cacheRecord.idToken) {\r\n            idTokenObj = new AuthToken(cacheRecord.idToken.secret, this.config.cryptoInterface);\r\n        }\r\n        return await ResponseHandler.generateAuthenticationResult(\r\n            this.cryptoUtils,\r\n            this.authority,\r\n            cacheRecord,\r\n            true,\r\n            idTokenObj,\r\n            undefined,\r\n            resourceRequestMethod,\r\n            resourceRequestUri\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Given a request object and an accessTokenEntity determine if the accessToken needs to be refreshed\r\n     * @param request\r\n     * @param cachedAccessToken\r\n     */\r\n    private isRefreshRequired(request: CommonSilentFlowRequest, cachedAccessToken: AccessTokenEntity|null): boolean {\r\n        if (request.forceRefresh || request.claims) {\r\n            // Must refresh due to request parameters\r\n            return true;\r\n        } else if (!cachedAccessToken || TimeUtils.isTokenExpired(cachedAccessToken.expiresOn, this.config.systemOptions.tokenRenewalOffsetSeconds)) {\r\n            // Must refresh due to expired or non-existent access_token\r\n            return true;\r\n        }\r\n\r\n        return false;\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { BaseClient } from \"./BaseClient\";\r\nimport { ClientConfiguration } from \"../config/ClientConfiguration\";\r\nimport { CommonUsernamePasswordRequest } from \"../request/CommonUsernamePasswordRequest\";\r\nimport { AuthenticationResult } from \"../response/AuthenticationResult\";\r\nimport { ResponseHandler } from \"../response/ResponseHandler\";\r\nimport { Authority } from \"../authority/Authority\";\r\nimport { NetworkResponse } from \"../network/NetworkManager\";\r\nimport { ServerAuthorizationTokenResponse } from \"../response/ServerAuthorizationTokenResponse\";\r\nimport { RequestParameterBuilder } from \"../request/RequestParameterBuilder\";\r\nimport { GrantType } from \"../utils/Constants\";\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\nimport { RequestThumbprint } from \"../network/RequestThumbprint\";\r\nimport { TimeUtils } from \"../utils/TimeUtils\";\r\n\r\n/**\r\n * Oauth2.0 Password grant client\r\n * Note: We are only supporting public clients for password grant and for purely testing purposes\r\n */\r\nexport class UsernamePasswordClient extends BaseClient {\r\n\r\n    constructor(configuration: ClientConfiguration) {\r\n        super(configuration);\r\n    }\r\n\r\n    /**\r\n     * API to acquire a token by passing the username and password to the service in exchage of credentials\r\n     * password_grant\r\n     * @param request\r\n     */\r\n    async acquireToken(request: CommonUsernamePasswordRequest): Promise<AuthenticationResult | null> {\r\n        this.logger.info(\"in acquireToken call\");\r\n\r\n        const reqTimestamp = TimeUtils.nowSeconds();\r\n        const response = await this.executeTokenRequest(this.authority, request);\r\n\r\n        const responseHandler = new ResponseHandler(\r\n            this.config.authOptions.clientId,\r\n            this.cacheManager,\r\n            this.cryptoUtils,\r\n            this.logger,\r\n            this.config.serializableCache,\r\n            this.config.persistencePlugin\r\n        );\r\n\r\n        // Validate response. This function throws a server error if an error is returned by the server.\r\n        responseHandler.validateTokenResponse(response.body);\r\n        const tokenResponse = responseHandler.handleServerTokenResponse(response.body, this.authority, reqTimestamp);\r\n\r\n        return tokenResponse;\r\n    }\r\n\r\n    /**\r\n     * Executes POST request to token endpoint\r\n     * @param authority\r\n     * @param request\r\n     */\r\n    private async executeTokenRequest(authority: Authority, request: CommonUsernamePasswordRequest): Promise<NetworkResponse<ServerAuthorizationTokenResponse>> {\r\n        const thumbprint: RequestThumbprint = {\r\n            clientId: this.config.authOptions.clientId,\r\n            authority: authority.canonicalAuthority,\r\n            scopes: request.scopes\r\n        };\r\n        const requestBody = this.createTokenRequestBody(request);\r\n        const headers: Record<string, string> = this.createDefaultTokenRequestHeaders();\r\n\r\n        return this.executePostToTokenEndpoint(authority.tokenEndpoint, requestBody, headers, thumbprint);\r\n    }\r\n\r\n    /**\r\n     * Generates a map for all the params to be sent to the service\r\n     * @param request\r\n     */\r\n    private createTokenRequestBody(request: CommonUsernamePasswordRequest): string {\r\n        const parameterBuilder = new RequestParameterBuilder();\r\n\r\n        parameterBuilder.addClientId(this.config.authOptions.clientId);\r\n        parameterBuilder.addUsername(request.username);\r\n        parameterBuilder.addPassword(request.password);\r\n\r\n        parameterBuilder.addScopes(request.scopes);\r\n\r\n        parameterBuilder.addGrantType(GrantType.RESOURCE_OWNER_PASSWORD_GRANT);\r\n        parameterBuilder.addClientInfo();\r\n\r\n        const correlationId = request.correlationId || this.config.cryptoInterface.createNewGuid();\r\n        parameterBuilder.addCorrelationId(correlationId);\r\n\r\n        if (!StringUtils.isEmpty(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {\r\n            parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);\r\n        }\r\n\r\n        return parameterBuilder.createQueryString();\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\n/**\r\n * Tenant Discovery Response which contains the relevant OAuth endpoints and data needed for authentication and authorization.\r\n */\r\nexport type OpenIdConfigResponse = {\r\n    authorization_endpoint: string;\r\n    token_endpoint: string;\r\n    end_session_endpoint: string;\r\n    issuer: string;\r\n};\r\n\r\nexport function isOpenIdConfigResponse(response: object): boolean {\r\n    return (\r\n        response.hasOwnProperty(\"authorization_endpoint\") &&\r\n        response.hasOwnProperty(\"token_endpoint\") && \r\n        response.hasOwnProperty(\"end_session_endpoint\") &&\r\n        response.hasOwnProperty(\"issuer\")\r\n    );\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\n/**\r\n * Protocol modes supported by MSAL.\r\n */\r\nexport enum ProtocolMode {\r\n    AAD = \"AAD\",\r\n    OIDC = \"OIDC\"\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { CloudDiscoveryMetadata } from \"../../authority/CloudDiscoveryMetadata\";\r\nimport { OpenIdConfigResponse } from \"../../authority/OpenIdConfigResponse\";\r\nimport { AUTHORITY_METADATA_CONSTANTS } from \"../../utils/Constants\";\r\nimport { TimeUtils } from \"../../utils/TimeUtils\";\r\n\r\nexport class AuthorityMetadataEntity {\r\n    aliases: Array<string>;\r\n    preferred_cache: string;\r\n    preferred_network: string;\r\n    canonical_authority: string;\r\n    authorization_endpoint: string;\r\n    token_endpoint: string;\r\n    end_session_endpoint: string;\r\n    issuer: string;\r\n    aliasesFromNetwork: boolean;\r\n    endpointsFromNetwork: boolean;\r\n    expiresAt: number;\r\n\r\n    constructor() {\r\n        this.expiresAt = TimeUtils.nowSeconds() + AUTHORITY_METADATA_CONSTANTS.REFRESH_TIME_SECONDS;\r\n    }\r\n\r\n    /**\r\n     * Update the entity with new aliases, preferred_cache and preferred_network values\r\n     * @param metadata \r\n     * @param fromNetwork \r\n     */\r\n    updateCloudDiscoveryMetadata(metadata: CloudDiscoveryMetadata, fromNetwork: boolean) {\r\n        this.aliases = metadata.aliases;\r\n        this.preferred_cache = metadata.preferred_cache;\r\n        this.preferred_network = metadata.preferred_network;\r\n        this.aliasesFromNetwork = fromNetwork;\r\n    }\r\n\r\n    /**\r\n     * Update the entity with new endpoints\r\n     * @param metadata \r\n     * @param fromNetwork \r\n     */\r\n    updateEndpointMetadata(metadata: OpenIdConfigResponse, fromNetwork: boolean) {\r\n        this.authorization_endpoint = metadata.authorization_endpoint;\r\n        this.token_endpoint = metadata.token_endpoint;\r\n        this.end_session_endpoint = metadata.end_session_endpoint;\r\n        this.issuer = metadata.issuer;\r\n        this.endpointsFromNetwork = fromNetwork;\r\n    }\r\n\r\n    /**\r\n     * Save the authority that was used to create this cache entry\r\n     * @param authority \r\n     */\r\n    updateCanonicalAuthority(authority: string) {\r\n        this.canonical_authority = authority;\r\n    }\r\n\r\n    /**\r\n     * Reset the exiresAt value\r\n     */\r\n    resetExpiresAt() {\r\n        this.expiresAt = TimeUtils.nowSeconds() + AUTHORITY_METADATA_CONSTANTS.REFRESH_TIME_SECONDS;\r\n    }\r\n\r\n    /**\r\n     * Returns whether or not the data needs to be refreshed\r\n     */\r\n    isExpired(): boolean {\r\n        return this.expiresAt <= TimeUtils.nowSeconds();\r\n    }\r\n\r\n    /**\r\n     * Validates an entity: checks for all expected params\r\n     * @param entity\r\n     */\r\n    static isAuthorityMetadataEntity(key: string, entity: object): boolean {\r\n\r\n        if (!entity) {\r\n            return false;\r\n        }\r\n\r\n        return (\r\n            key.indexOf(AUTHORITY_METADATA_CONSTANTS.CACHE_KEY) === 0 &&\r\n            entity.hasOwnProperty(\"aliases\") &&\r\n            entity.hasOwnProperty(\"preferred_cache\") &&\r\n            entity.hasOwnProperty(\"preferred_network\") &&\r\n            entity.hasOwnProperty(\"canonical_authority\") &&\r\n            entity.hasOwnProperty(\"authorization_endpoint\") &&\r\n            entity.hasOwnProperty(\"token_endpoint\") &&\r\n            entity.hasOwnProperty(\"end_session_endpoint\") &&\r\n            entity.hasOwnProperty(\"issuer\") &&\r\n            entity.hasOwnProperty(\"aliasesFromNetwork\") &&\r\n            entity.hasOwnProperty(\"endpointsFromNetwork\") &&\r\n            entity.hasOwnProperty(\"expiresAt\")\r\n        );\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { CloudDiscoveryMetadata } from \"./CloudDiscoveryMetadata\";\r\n\r\n/**\r\n * The OpenID Configuration Endpoint Response type. Used by the authority class to get relevant OAuth endpoints.\r\n */\r\nexport type CloudInstanceDiscoveryResponse = {\r\n    tenant_discovery_endpoint: string;\r\n    metadata: Array<CloudDiscoveryMetadata>;\r\n};\r\n\r\nexport function isCloudInstanceDiscoveryResponse(response: object): boolean {\r\n    return (\r\n        response.hasOwnProperty(\"tenant_discovery_endpoint\") &&\r\n        response.hasOwnProperty(\"metadata\")\r\n    );\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { AuthorityType } from \"./AuthorityType\";\r\nimport { isOpenIdConfigResponse, OpenIdConfigResponse } from \"./OpenIdConfigResponse\";\r\nimport { UrlString } from \"../url/UrlString\";\r\nimport { IUri } from \"../url/IUri\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\nimport { INetworkModule } from \"../network/INetworkModule\";\r\nimport { AuthorityMetadataSource, Constants } from \"../utils/Constants\";\r\nimport { ClientConfigurationError } from \"../error/ClientConfigurationError\";\r\nimport { ProtocolMode } from \"./ProtocolMode\";\r\nimport { ICacheManager } from \"../cache/interface/ICacheManager\";\r\nimport { AuthorityMetadataEntity } from \"../cache/entities/AuthorityMetadataEntity\";\r\nimport { AuthorityOptions } from \"./AuthorityOptions\";\r\nimport { CloudInstanceDiscoveryResponse, isCloudInstanceDiscoveryResponse } from \"./CloudInstanceDiscoveryResponse\";\r\nimport { CloudDiscoveryMetadata } from \"./CloudDiscoveryMetadata\";\r\n\r\n/**\r\n * The authority class validates the authority URIs used by the user, and retrieves the OpenID Configuration Data from the\r\n * endpoint. It will store the pertinent config data in this object for use during token calls.\r\n */\r\nexport class Authority {\r\n\r\n    // Canonical authority url string\r\n    private _canonicalAuthority: UrlString;\r\n    // Canonicaly authority url components\r\n    private _canonicalAuthorityUrlComponents: IUri | null;\r\n    // Network interface to make requests with.\r\n    protected networkInterface: INetworkModule;\r\n    // Cache Manager to cache network responses\r\n    protected cacheManager: ICacheManager;\r\n    // Protocol mode to construct endpoints\r\n    private authorityOptions: AuthorityOptions;\r\n    // Authority metadata\r\n    private metadata: AuthorityMetadataEntity;\r\n\r\n    constructor(authority: string, networkInterface: INetworkModule, cacheManager: ICacheManager, authorityOptions: AuthorityOptions) {\r\n        this.canonicalAuthority = authority;\r\n        this._canonicalAuthority.validateAsUri();\r\n        this.networkInterface = networkInterface;\r\n        this.cacheManager = cacheManager;\r\n        this.authorityOptions = authorityOptions;\r\n    }\r\n\r\n    // See above for AuthorityType\r\n    public get authorityType(): AuthorityType {\r\n        const pathSegments = this.canonicalAuthorityUrlComponents.PathSegments;\r\n\r\n        if (pathSegments.length && pathSegments[0].toLowerCase() === Constants.ADFS) {\r\n            return AuthorityType.Adfs;\r\n        }\r\n\r\n        return AuthorityType.Default;\r\n    }\r\n\r\n    /**\r\n     * ProtocolMode enum representing the way endpoints are constructed.\r\n     */\r\n    public get protocolMode(): ProtocolMode {\r\n        return this.authorityOptions.protocolMode;\r\n    }\r\n\r\n    /**\r\n     * Returns authorityOptions which can be used to reinstantiate a new authority instance\r\n     */\r\n    public get options(): AuthorityOptions {\r\n        return this.authorityOptions;\r\n    }\r\n\r\n    /**\r\n     * A URL that is the authority set by the developer\r\n     */\r\n    public get canonicalAuthority(): string {\r\n        return this._canonicalAuthority.urlString;\r\n    }\r\n\r\n    /**\r\n     * Sets canonical authority.\r\n     */\r\n    public set canonicalAuthority(url: string) {\r\n        this._canonicalAuthority = new UrlString(url);\r\n        this._canonicalAuthority.validateAsUri();\r\n        this._canonicalAuthorityUrlComponents = null;\r\n    }\r\n\r\n    /**\r\n     * Get authority components.\r\n     */\r\n    public get canonicalAuthorityUrlComponents(): IUri {\r\n        if (!this._canonicalAuthorityUrlComponents) {\r\n            this._canonicalAuthorityUrlComponents = this._canonicalAuthority.getUrlComponents();\r\n        }\r\n\r\n        return this._canonicalAuthorityUrlComponents;\r\n    }\r\n\r\n    /**\r\n     * Get hostname and port i.e. login.microsoftonline.com\r\n     */\r\n    public get hostnameAndPort(): string {\r\n        return this.canonicalAuthorityUrlComponents.HostNameAndPort.toLowerCase();\r\n    }\r\n\r\n    /**\r\n     * Get tenant for authority.\r\n     */\r\n    public get tenant(): string {\r\n        return this.canonicalAuthorityUrlComponents.PathSegments[0];\r\n    }\r\n\r\n    /**\r\n     * OAuth /authorize endpoint for requests\r\n     */\r\n    public get authorizationEndpoint(): string {\r\n        if(this.discoveryComplete()) {\r\n            const endpoint = this.replacePath(this.metadata.authorization_endpoint);\r\n            return this.replaceTenant(endpoint);\r\n        } else {\r\n            throw ClientAuthError.createEndpointDiscoveryIncompleteError(\"Discovery incomplete.\");\r\n        }\r\n    }\r\n\r\n    /**\r\n     * OAuth /token endpoint for requests\r\n     */\r\n    public get tokenEndpoint(): string {\r\n        if(this.discoveryComplete()) {\r\n            const endpoint = this.replacePath(this.metadata.token_endpoint);\r\n            return this.replaceTenant(endpoint);\r\n        } else {\r\n            throw ClientAuthError.createEndpointDiscoveryIncompleteError(\"Discovery incomplete.\");\r\n        }\r\n    }\r\n\r\n    public get deviceCodeEndpoint(): string {\r\n        if(this.discoveryComplete()) {\r\n            const endpoint = this.replacePath(this.metadata.token_endpoint.replace(\"/token\", \"/devicecode\"));\r\n            return this.replaceTenant(endpoint);\r\n        } else {\r\n            throw ClientAuthError.createEndpointDiscoveryIncompleteError(\"Discovery incomplete.\");\r\n        }\r\n    }\r\n\r\n    /**\r\n     * OAuth logout endpoint for requests\r\n     */\r\n    public get endSessionEndpoint(): string {\r\n        if(this.discoveryComplete()) {\r\n            const endpoint = this.replacePath(this.metadata.end_session_endpoint);\r\n            return this.replaceTenant(endpoint);\r\n        } else {\r\n            throw ClientAuthError.createEndpointDiscoveryIncompleteError(\"Discovery incomplete.\");\r\n        }\r\n    }\r\n\r\n    /**\r\n     * OAuth issuer for requests\r\n     */\r\n    public get selfSignedJwtAudience(): string {\r\n        if(this.discoveryComplete()) {\r\n            const endpoint = this.replacePath(this.metadata.issuer);\r\n            return this.replaceTenant(endpoint);\r\n        } else {\r\n            throw ClientAuthError.createEndpointDiscoveryIncompleteError(\"Discovery incomplete.\");\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Replaces tenant in url path with current tenant. Defaults to common.\r\n     * @param urlString\r\n     */\r\n    private replaceTenant(urlString: string): string {\r\n        return urlString.replace(/{tenant}|{tenantid}/g, this.tenant);\r\n    }\r\n\r\n    /**\r\n     * Replaces path such as tenant or policy with the current tenant or policy.\r\n     * @param urlString \r\n     */\r\n    private replacePath(urlString: string): string {\r\n        let endpoint = urlString;\r\n        const cachedAuthorityUrl = new UrlString(this.metadata.canonical_authority);\r\n        const cachedAuthorityParts = cachedAuthorityUrl.getUrlComponents().PathSegments;\r\n        const currentAuthorityParts = this.canonicalAuthorityUrlComponents.PathSegments;\r\n\r\n        currentAuthorityParts.forEach((currentPart, index) => {\r\n            const cachedPart = cachedAuthorityParts[index];\r\n            if (currentPart !== cachedPart) {\r\n                endpoint = endpoint.replace(`/${cachedPart}/`, `/${currentPart}/`);\r\n            }\r\n        });\r\n\r\n        return endpoint;\r\n    }\r\n\r\n    /**\r\n     * The default open id configuration endpoint for any canonical authority.\r\n     */\r\n    protected get defaultOpenIdConfigurationEndpoint(): string {\r\n        if (this.authorityType === AuthorityType.Adfs || this.protocolMode === ProtocolMode.OIDC) {\r\n            return `${this.canonicalAuthority}.well-known/openid-configuration`;\r\n        }\r\n        return `${this.canonicalAuthority}v2.0/.well-known/openid-configuration`;\r\n    }\r\n\r\n    /**\r\n     * Boolean that returns whethr or not tenant discovery has been completed.\r\n     */\r\n    discoveryComplete(): boolean {\r\n        return !!this.metadata;\r\n    }\r\n\r\n    /**\r\n     * Perform endpoint discovery to discover aliases, preferred_cache, preferred_network\r\n     * and the /authorize, /token and logout endpoints.\r\n     */\r\n    public async resolveEndpointsAsync(): Promise<void> {\r\n        let metadataEntity = this.cacheManager.getAuthorityMetadataByAlias(this.hostnameAndPort);\r\n        if (!metadataEntity) {\r\n            metadataEntity = new AuthorityMetadataEntity();\r\n            metadataEntity.updateCanonicalAuthority(this.canonicalAuthority);\r\n        }\r\n\r\n        const cloudDiscoverySource = await this.updateCloudDiscoveryMetadata(metadataEntity);\r\n        this.canonicalAuthority = this.canonicalAuthority.replace(this.hostnameAndPort, metadataEntity.preferred_network);\r\n        const endpointSource = await this.updateEndpointMetadata(metadataEntity);\r\n\r\n        if (cloudDiscoverySource !== AuthorityMetadataSource.CACHE && endpointSource !== AuthorityMetadataSource.CACHE) {\r\n            // Reset the expiration time unless both values came from a successful cache lookup\r\n            metadataEntity.resetExpiresAt();\r\n            metadataEntity.updateCanonicalAuthority(this.canonicalAuthority);\r\n        } \r\n\r\n        const cacheKey = this.cacheManager.generateAuthorityMetadataCacheKey(metadataEntity.preferred_cache);\r\n        this.cacheManager.setAuthorityMetadata(cacheKey, metadataEntity);\r\n        this.metadata = metadataEntity;\r\n    }\r\n\r\n    /**\r\n     * Update AuthorityMetadataEntity with new endpoints and return where the information came from\r\n     * @param metadataEntity \r\n     */\r\n    private async updateEndpointMetadata(metadataEntity: AuthorityMetadataEntity): Promise<AuthorityMetadataSource> {\r\n        let metadata = this.getEndpointMetadataFromConfig();\r\n        if (metadata) {\r\n            metadataEntity.updateEndpointMetadata(metadata, false);\r\n            return AuthorityMetadataSource.CONFIG;\r\n        }\r\n\r\n        if (this.isAuthoritySameType(metadataEntity) && metadataEntity.endpointsFromNetwork && !metadataEntity.isExpired()) {\r\n            // No need to update\r\n            return AuthorityMetadataSource.CACHE;\r\n        }\r\n\r\n        metadata = await this.getEndpointMetadataFromNetwork();\r\n        if (metadata) {\r\n            metadataEntity.updateEndpointMetadata(metadata, true);\r\n            return AuthorityMetadataSource.NETWORK;\r\n        } else {\r\n            throw ClientAuthError.createUnableToGetOpenidConfigError(this.defaultOpenIdConfigurationEndpoint);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Compares the number of url components after the domain to determine if the cached authority metadata can be used for the requested authority\r\n     * Protects against same domain different authority such as login.microsoftonline.com/tenant and login.microsoftonline.com/tfp/tenant/policy\r\n     * @param metadataEntity\r\n     */\r\n    private isAuthoritySameType(metadataEntity: AuthorityMetadataEntity): boolean {\r\n        const cachedAuthorityUrl = new UrlString(metadataEntity.canonical_authority);\r\n        const cachedParts = cachedAuthorityUrl.getUrlComponents().PathSegments;\r\n        \r\n        return cachedParts.length === this.canonicalAuthorityUrlComponents.PathSegments.length;\r\n    }\r\n\r\n    /**\r\n     * Parse authorityMetadata config option\r\n     */\r\n    private getEndpointMetadataFromConfig(): OpenIdConfigResponse | null {\r\n        if (this.authorityOptions.authorityMetadata) {\r\n            try {\r\n                return JSON.parse(this.authorityOptions.authorityMetadata) as OpenIdConfigResponse;\r\n            } catch (e) {\r\n                throw ClientConfigurationError.createInvalidAuthorityMetadataError();\r\n            }\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    /**\r\n     * Gets OAuth endpoints from the given OpenID configuration endpoint.\r\n     */\r\n    private async getEndpointMetadataFromNetwork(): Promise<OpenIdConfigResponse | null> {\r\n        try {\r\n            const response = await this.networkInterface.sendGetRequestAsync<OpenIdConfigResponse>(this.defaultOpenIdConfigurationEndpoint);\r\n            return isOpenIdConfigResponse(response.body) ? response.body : null;\r\n        } catch (e) {\r\n            return null;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Updates the AuthorityMetadataEntity with new aliases, preferred_network and preferred_cache and returns where the information was retrived from\r\n     * @param cachedMetadata \r\n     * @param newMetadata \r\n     */\r\n    private async updateCloudDiscoveryMetadata(metadataEntity: AuthorityMetadataEntity): Promise<AuthorityMetadataSource> {\r\n        let metadata = this.getCloudDiscoveryMetadataFromConfig();\r\n        if (metadata) {\r\n            metadataEntity.updateCloudDiscoveryMetadata(metadata, false);\r\n            return AuthorityMetadataSource.CONFIG;\r\n        }\r\n\r\n        // If The cached metadata came from config but that config was not passed to this instance, we must go to the network\r\n        if (this.isAuthoritySameType(metadataEntity) && metadataEntity.aliasesFromNetwork && !metadataEntity.isExpired()) {\r\n            // No need to update\r\n            return AuthorityMetadataSource.CACHE;\r\n        }\r\n\r\n        metadata = await this.getCloudDiscoveryMetadataFromNetwork();\r\n        if (metadata) {\r\n            metadataEntity.updateCloudDiscoveryMetadata(metadata, true);\r\n            return AuthorityMetadataSource.NETWORK;\r\n        } else {\r\n            // Metadata could not be obtained from config, cache or network\r\n            throw ClientConfigurationError.createUntrustedAuthorityError();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Parse cloudDiscoveryMetadata config or check knownAuthorities\r\n     */\r\n    private getCloudDiscoveryMetadataFromConfig(): CloudDiscoveryMetadata | null {\r\n        // Check if network response was provided in config\r\n        if (this.authorityOptions.cloudDiscoveryMetadata) {\r\n            try {\r\n                const parsedResponse = JSON.parse(this.authorityOptions.cloudDiscoveryMetadata) as CloudInstanceDiscoveryResponse;\r\n                const metadata = Authority.getCloudDiscoveryMetadataFromNetworkResponse(parsedResponse.metadata, this.hostnameAndPort);\r\n                if (metadata) {\r\n                    return metadata;\r\n                }\r\n            } catch (e) {\r\n                throw ClientConfigurationError.createInvalidCloudDiscoveryMetadataError();\r\n            }\r\n        }\r\n\r\n        // If cloudDiscoveryMetadata is empty or does not contain the host, check knownAuthorities\r\n        if (this.isInKnownAuthorities()) {\r\n            return Authority.createCloudDiscoveryMetadataFromHost(this.hostnameAndPort);\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    /**\r\n     * Called to get metadata from network if CloudDiscoveryMetadata was not populated by config\r\n     * @param networkInterface \r\n     */\r\n    private async getCloudDiscoveryMetadataFromNetwork(): Promise<CloudDiscoveryMetadata | null> {\r\n        const instanceDiscoveryEndpoint = `${Constants.AAD_INSTANCE_DISCOVERY_ENDPT}${this.canonicalAuthority}oauth2/v2.0/authorize`;\r\n        let match = null;\r\n        try {\r\n            const response = await this.networkInterface.sendGetRequestAsync<CloudInstanceDiscoveryResponse>(instanceDiscoveryEndpoint);\r\n            const metadata = isCloudInstanceDiscoveryResponse(response.body) ? response.body.metadata : [];\r\n            match = Authority.getCloudDiscoveryMetadataFromNetworkResponse(metadata, this.hostnameAndPort);\r\n        } catch(e) {\r\n            return null;\r\n        }\r\n\r\n        if (!match) {\r\n            // Custom Domain scenario, host is trusted because Instance Discovery call succeeded \r\n            match = Authority.createCloudDiscoveryMetadataFromHost(this.hostnameAndPort);\r\n        }\r\n        return match;\r\n    } \r\n\r\n    /**\r\n     * Helper function to determine if this host is included in the knownAuthorities config option\r\n     */\r\n    private isInKnownAuthorities(): boolean {\r\n        const matches = this.authorityOptions.knownAuthorities.filter((authority) => {\r\n            return UrlString.getDomainFromUrl(authority).toLowerCase() === this.hostnameAndPort;\r\n        });\r\n\r\n        return matches.length > 0;\r\n    }\r\n\r\n    /**\r\n     * Creates cloud discovery metadata object from a given host\r\n     * @param host \r\n     */\r\n    static createCloudDiscoveryMetadataFromHost(host: string): CloudDiscoveryMetadata {\r\n        return {\r\n            preferred_network: host,\r\n            preferred_cache: host,\r\n            aliases: [host]\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Searches instance discovery network response for the entry that contains the host in the aliases list\r\n     * @param response \r\n     * @param authority \r\n     */\r\n    static getCloudDiscoveryMetadataFromNetworkResponse(response: CloudDiscoveryMetadata[], authority: string): CloudDiscoveryMetadata | null {\r\n        for (let i = 0; i < response.length; i++) {\r\n            const metadata = response[i];\r\n            if (metadata.aliases.indexOf(authority) > -1) {\r\n                return metadata;\r\n            }\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    /**\r\n     * helper function to generate environment from authority object\r\n     */\r\n    getPreferredCache(): string {\r\n        if(this.discoveryComplete()) {\r\n            return this.metadata.preferred_cache;\r\n        } else {\r\n            throw ClientAuthError.createEndpointDiscoveryIncompleteError(\"Discovery incomplete.\");\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns whether or not the provided host is an alias of this authority instance\r\n     * @param host \r\n     */\r\n    isAlias(host: string): boolean {\r\n        return this.metadata.aliases.indexOf(host) > -1;\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { Authority } from \"./Authority\";\r\nimport { ClientConfigurationError } from \"../error/ClientConfigurationError\";\r\nimport { INetworkModule } from \"../network/INetworkModule\";\r\nimport { StringUtils } from \"../utils/StringUtils\";\r\nimport { ClientAuthError } from \"../error/ClientAuthError\";\r\nimport { ICacheManager } from \"../cache/interface/ICacheManager\";\r\nimport { AuthorityOptions } from \"./AuthorityOptions\";\r\n\r\nexport class AuthorityFactory {\r\n\r\n    /**\r\n     * Create an authority object of the correct type based on the url\r\n     * Performs basic authority validation - checks to see if the authority is of a valid type (i.e. aad, b2c, adfs)\r\n     *\r\n     * Also performs endpoint discovery.\r\n     *\r\n     * @param authorityUri\r\n     * @param networkClient\r\n     * @param protocolMode\r\n     */\r\n    static async createDiscoveredInstance(authorityUri: string, networkClient: INetworkModule, cacheManager: ICacheManager, authorityOptions: AuthorityOptions): Promise<Authority> {\r\n        // Initialize authority and perform discovery endpoint check.\r\n        const acquireTokenAuthority: Authority = AuthorityFactory.createInstance(authorityUri, networkClient, cacheManager, authorityOptions);\r\n\r\n        try {\r\n            await acquireTokenAuthority.resolveEndpointsAsync();\r\n            return acquireTokenAuthority;\r\n        } catch (e) {\r\n            throw ClientAuthError.createEndpointDiscoveryIncompleteError(e);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Create an authority object of the correct type based on the url\r\n     * Performs basic authority validation - checks to see if the authority is of a valid type (i.e. aad, b2c, adfs)\r\n     *\r\n     * Does not perform endpoint discovery.\r\n     *\r\n     * @param authorityUrl\r\n     * @param networkInterface\r\n     * @param protocolMode\r\n     */\r\n    static createInstance(authorityUrl: string, networkInterface: INetworkModule, cacheManager: ICacheManager, authorityOptions: AuthorityOptions): Authority {\r\n        // Throw error if authority url is empty\r\n        if (StringUtils.isEmpty(authorityUrl)) {\r\n            throw ClientConfigurationError.createUrlEmptyError();\r\n        }\r\n\r\n        return new Authority(authorityUrl, networkInterface, cacheManager, authorityOptions);\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { SERVER_TELEM_CONSTANTS } from \"../../utils/Constants\";\r\n\r\nexport class ServerTelemetryEntity {\r\n    failedRequests: Array<string|number>;\r\n    errors: string[];\r\n    cacheHits: number;\r\n\r\n    constructor() {\r\n        this.failedRequests = [];\r\n        this.errors = [];\r\n        this.cacheHits = 0;\r\n    }\r\n\r\n    /**\r\n     * validates if a given cache entry is \"Telemetry\", parses <key,value>\r\n     * @param key\r\n     * @param entity\r\n     */\r\n    static isServerTelemetryEntity(key: string, entity?: object): boolean {\r\n\r\n        const validateKey: boolean = key.indexOf(SERVER_TELEM_CONSTANTS.CACHE_KEY) === 0;\r\n        let validateEntity: boolean = true;\r\n\r\n        if (entity) {\r\n            validateEntity =\r\n                entity.hasOwnProperty(\"failedRequests\") &&\r\n                entity.hasOwnProperty(\"errors\") &&\r\n                entity.hasOwnProperty(\"cacheHits\");\r\n        }\r\n\r\n        return validateKey && validateEntity;\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { ThrottlingConstants } from \"../../utils/Constants\";\r\n\r\nexport class ThrottlingEntity {\r\n    // Unix-time value representing the expiration of the throttle\r\n    throttleTime: number;\r\n    // Information provided by the server\r\n    error?: string;\r\n    errorCodes?: Array<string>;\r\n    errorMessage?: string;\r\n    subError?: string;\r\n\r\n    /**\r\n     * validates if a given cache entry is \"Throttling\", parses <key,value>\r\n     * @param key\r\n     * @param entity\r\n     */\r\n    static isThrottlingEntity(key: string, entity?: object): boolean {\r\n        \r\n        let validateKey: boolean = false;\r\n        if (key) {\r\n            validateKey = key.indexOf(ThrottlingConstants.THROTTLING_PREFIX) === 0;\r\n        }\r\n        \r\n        let validateEntity: boolean = true;\r\n        if (entity) {\r\n            validateEntity = entity.hasOwnProperty(\"throttleTime\");\r\n        }\r\n\r\n        return validateKey && validateEntity;\r\n    }\r\n}\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { AuthError } from \"../error/AuthError\";\r\nimport { NetworkResponse } from \"./NetworkManager\";\r\n\r\n/**\r\n * Options allowed by network request APIs.\r\n */\r\nexport type NetworkRequestOptions = {\r\n    headers?: Record<string, string>,\r\n    body?: string;\r\n};\r\n\r\n/**\r\n * Client network interface to send backend requests.\r\n * @interface\r\n */\r\nexport interface INetworkModule {\r\n\r\n    /**\r\n     * Interface function for async network \"GET\" requests. Based on the Fetch standard: https://fetch.spec.whatwg.org/\r\n     * @param url\r\n     * @param requestParams\r\n     * @param enableCaching\r\n     */\r\n    sendGetRequestAsync<T>(url: string, options?: NetworkRequestOptions): Promise<NetworkResponse<T>>;\r\n\r\n    /**\r\n     * Interface function for async network \"POST\" requests. Based on the Fetch standard: https://fetch.spec.whatwg.org/\r\n     * @param url\r\n     * @param requestParams\r\n     * @param enableCaching\r\n     */\r\n    sendPostRequestAsync<T>(url: string, options?: NetworkRequestOptions): Promise<NetworkResponse<T>>;\r\n}\r\n\r\nexport const StubbedNetworkModule: INetworkModule = {\r\n    sendGetRequestAsync: () => {\r\n        const notImplErr = \"Network interface - sendGetRequestAsync() has not been implemented for the Network interface.\";\r\n        return Promise.reject(AuthError.createUnexpectedError(notImplErr));\r\n    },\r\n    sendPostRequestAsync: () => {\r\n        const notImplErr = \"Network interface - sendPostRequestAsync() has not been implemented for the Network interface.\";\r\n        return Promise.reject(AuthError.createUnexpectedError(notImplErr));\r\n    }\r\n};\r\n","/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { SERVER_TELEM_CONSTANTS, Separators, Constants } from \"../../utils/Constants\";\r\nimport { CacheManager } from \"../../cache/CacheManager\";\r\nimport { AuthError } from \"../../error/AuthError\";\r\nimport { ServerTelemetryRequest } from \"./ServerTelemetryRequest\";\r\nimport { ServerTelemetryEntity } from \"../../cache/entities/ServerTelemetryEntity\";\r\nimport { StringUtils } from \"../../utils/StringUtils\";\r\n\r\nexport class ServerTelemetryManager {\r\n    private cacheManager: CacheManager;\r\n    private apiId: number;\r\n    private correlationId: string;\r\n    private forceRefresh: boolean;\r\n    private telemetryCacheKey: string;\r\n    private wrapperSKU: String;\r\n    private wrapperVer: String;\r\n\r\n    constructor(telemetryRequest: ServerTelemetryRequest, cacheManager: CacheManager) {\r\n        this.cacheManager = cacheManager;\r\n        this.apiId = telemetryRequest.apiId;\r\n        this.correlationId = telemetryRequest.correlationId;\r\n        this.forceRefresh = telemetryRequest.forceRefresh || false;\r\n        this.wrapperSKU = telemetryRequest.wrapperSKU || Constants.EMPTY_STRING;\r\n        this.wrapperVer = telemetryRequest.wrapperVer || Constants.EMPTY_STRING;\r\n\r\n        this.telemetryCacheKey = SERVER_TELEM_CONSTANTS.CACHE_KEY + Separators.CACHE_KEY_SEPARATOR + telemetryRequest.clientId;\r\n    }\r\n\r\n    /**\r\n     * API to add MSER Telemetry to request\r\n     */\r\n    generateCurrentRequestHeaderValue(): string {\r\n        const forceRefreshInt = this.forceRefresh ? 1 : 0;\r\n        const request = `${this.apiId}${SERVER_TELEM_CONSTANTS.VALUE_SEPARATOR}${forceRefreshInt}`;\r\n        const platformFields = [this.wrapperSKU, this.wrapperVer].join(SERVER_TELEM_CONSTANTS.VALUE_SEPARATOR);\r\n\r\n        return [SERVER_TELEM_CONSTANTS.SCHEMA_VERSION, request, platformFields].join(SERVER_TELEM_CONSTANTS.CATEGORY_SEPARATOR);\r\n    }\r\n\r\n    /**\r\n     * API to add MSER Telemetry for the last failed request\r\n     */\r\n    generateLastRequestHeaderValue(): string {\r\n        const lastRequests = this.getLastRequests();\r\n\r\n        const maxErrors = ServerTelemetryManager.maxErrorsToSend(lastRequests);\r\n        const failedRequests = lastRequests.failedRequests.slice(0, 2*maxErrors).join(SERVER_TELEM_CONSTANTS.VALUE_SEPARATOR);\r\n        const errors = lastRequests.errors.slice(0, maxErrors).join(SERVER_TELEM_CONSTANTS.VALUE_SEPARATOR);\r\n        const errorCount = lastRequests.errors.length;\r\n\r\n        // Indicate whether this header contains all data or partial data\r\n        const overflow = maxErrors < errorCount ? SERVER_TELEM_CONSTANTS.OVERFLOW_TRUE : SERVER_TELEM_CONSTANTS.OVERFLOW_FALSE;\r\n        const platformFields = [errorCount, overflow].join(SERVER_TELEM_CONSTANTS.VALUE_SEPARATOR);\r\n\r\n        return [SERVER_TELEM_CONSTANTS.SCHEMA_VERSION, lastRequests.cacheHits, failedRequests, errors, platformFields].join(SERVER_TELEM_CONSTANTS.CATEGORY_SEPARATOR);\r\n    }\r\n\r\n    /**\r\n     * API to cache token failures for MSER data capture\r\n     * @param error\r\n     */\r\n    cacheFailedRequest(error: AuthError): void {\r\n        const lastRequests = this.getLastRequests();\r\n        lastRequests.failedRequests.push(this.apiId, this.correlationId);\r\n\r\n        if (!StringUtils.isEmpty(error.subError)) {\r\n            lastRequests.errors.push(error.subError);\r\n        } else if (!StringUtils.isEmpty(error.errorCode)) {\r\n            lastRequests.errors.push(error.errorCode);\r\n        } else if (!!error && error.toString()) {\r\n            lastRequests.errors.push(error.toString());\r\n        } else {\r\n            lastRequests.errors.push(SERVER_TELEM_CONSTANTS.UNKNOWN_ERROR);\r\n        }\r\n\r\n        this.cacheManager.setServerTelemetry(this.telemetryCacheKey, lastRequests);\r\n\r\n        return;\r\n    }\r\n\r\n    /**\r\n     * Update server telemetry cache entry by incrementing cache hit counter\r\n     */\r\n    incrementCacheHits(): number {\r\n        const lastRequests = this.getLastRequests();\r\n        lastRequests.cacheHits += 1;\r\n\r\n        this.cacheManager.setServerTelemetry(this.telemetryCacheKey, lastRequests);\r\n        return lastRequests.cacheHits;\r\n    }\r\n\r\n    /**\r\n     * Get the server telemetry entity from cache or initialize a new one\r\n     */\r\n    getLastRequests(): ServerTelemetryEntity {\r\n        const initialValue: ServerTelemetryEntity = new ServerTelemetryEntity();\r\n        const lastRequests = this.cacheManager.getServerTelemetry(this.telemetryCacheKey) as ServerTelemetryEntity;\r\n\r\n        return lastRequests || initialValue;\r\n    }\r\n\r\n    /**\r\n     * Remove server telemetry cache entry\r\n     */\r\n    clearTelemetryCache(): void {\r\n        const lastRequests = this.getLastRequests();\r\n        const numErrorsFlushed = ServerTelemetryManager.maxErrorsToSend(lastRequests);\r\n        const errorCount = lastRequests.errors.length;\r\n        if (numErrorsFlushed === errorCount) {\r\n            // All errors were sent on last request, clear Telemetry cache\r\n            this.cacheManager.removeItem(this.telemetryCacheKey);\r\n        } else {\r\n            // Partial data was flushed to server, construct a new telemetry cache item with errors that were not flushed\r\n            const serverTelemEntity = new ServerTelemetryEntity();\r\n            serverTelemEntity.failedRequests = lastRequests.failedRequests.slice(numErrorsFlushed*2); // failedRequests contains 2 items for each error\r\n            serverTelemEntity.errors = lastRequests.errors.slice(numErrorsFlushed);\r\n\r\n            this.cacheManager.setServerTelemetry(this.telemetryCacheKey, serverTelemEntity);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns the maximum number of errors that can be flushed to the server in the next network request\r\n     * @param serverTelemetryEntity\r\n     */\r\n    static maxErrorsToSend(serverTelemetryEntity: ServerTelemetryEntity): number {\r\n        let i;\r\n        let maxErrors = 0;\r\n        let dataSize = 0;\r\n        const errorCount = serverTelemetryEntity.errors.length;\r\n        for (i = 0; i < errorCount; i++) {\r\n            // failedRequests parameter contains pairs of apiId and correlationId, multiply index by 2 to preserve pairs\r\n            const apiId = serverTelemetryEntity.failedRequests[2*i] || Constants.EMPTY_STRING;\r\n            const correlationId = serverTelemetryEntity.failedRequests[2*i + 1] || Constants.EMPTY_STRING;\r\n            const errorCode = serverTelemetryEntity.errors[i] || Constants.EMPTY_STRING;\r\n\r\n            // Count number of characters that would be added to header, each character is 1 byte. Add 3 at the end to account for separators\r\n            dataSize += apiId.toString().length + correlationId.toString().length + errorCode.length + 3;\r\n\r\n            if (dataSize < SERVER_TELEM_CONSTANTS.MAX_HEADER_BYTES) {\r\n                // Adding this entry to the header would still keep header size below the limit\r\n                maxErrors += 1;\r\n            } else {\r\n                break;\r\n            }\r\n        }\r\n\r\n        return maxErrors;\r\n    }\r\n}\r\n"],"names":[],"mappings":"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"}
|