perimeterx-js-core 0.16.1 → 0.18.0

package/lib/esm/enforcer/utils.js

@@ -0,0 +1,79 @@
+import { DefaultTokenV2Parser, DefaultTokenV3Parser, TokenVersion } from '../risk_token';
+import { DefaultRemoteConfigUpdater, HttpRemoteConfigServiceClient } from '../config';
+import { DefaultCors } from '../cors';
+import { DefaultTelemetry } from '../telemetry';
+import { DefaultDataEnrichment } from '../pxde';
+import { DefaultGraphQLParser } from '../graphql';
+import { PostRiskApiClientV2, PostRiskApiClientV3 } from '../risk_api';
+import { HttpActivityClient, HttpBatchedActivityClient } from '../activities';
+import { HttpLogServiceClient } from '../logger';
+import { AccountDefender, BotDefender, CredentialIntelligence, HypeSaleChallenge, ProductName, } from '../products';
+export const createEnforcerInitializationBlock = (config, options) => {
+    const { tokenVersion, httpClient, base64Utils, hmacUtils, hashUtils, urlUtils, ipRangeChecker } = options;
+    const cipherUtils = tokenVersion === TokenVersion.V2 ? null : options.cipherUtils;
+    const cors = options.cors || new DefaultCors(config);
+    const telemetry = options.telemetry || new DefaultTelemetry(config, httpClient, base64Utils, hmacUtils);
+    const dataEnrichment = options.dataEnrichment || new DefaultDataEnrichment(config, base64Utils, hmacUtils);
+    const graphQLParser = options.graphQLParser || new DefaultGraphQLParser(config);
+    const tokenParser = options.tokenParser ||
+        (tokenVersion === TokenVersion.V2
+            ? new DefaultTokenV2Parser(config, { base64Utils, hmacUtils })
+            : new DefaultTokenV3Parser(config, { cipherUtils, hmacUtils }));
+    const riskApiClient = options.riskApiClient ||
+        (tokenVersion === TokenVersion.V2
+            ? new PostRiskApiClientV2(config, httpClient)
+            : new PostRiskApiClientV3(config, httpClient));
+    const activityClient = options.activityClient ||
+        (config.maxActivityBatchSize > 1
+            ? new HttpBatchedActivityClient(config, httpClient)
+            : new HttpActivityClient(config, httpClient));
+    const logServiceClient = options.logServiceClient || (config.loggerAuthToken ? new HttpLogServiceClient(config, httpClient) : null);
+    const remoteConfigStorageClient = options.remoteConfigStorageClient;
+    const remoteConfigServiceClient = options.remoteConfigServiceClient ||
+        (config.remoteConfigAuthToken ? new HttpRemoteConfigServiceClient(config, httpClient) : null);
+    const remoteConfigUpdater = options.remoteConfigUpdater ||
+        (remoteConfigStorageClient && remoteConfigServiceClient
+            ? new DefaultRemoteConfigUpdater(config, {
+                serviceClient: remoteConfigServiceClient,
+                storageClient: remoteConfigStorageClient,
+                base64Utils,
+                hmacUtils,
+            })
+            : null);
+    const allOptions = {
+        httpClient,
+        base64Utils,
+        hmacUtils,
+        hashUtils,
+        urlUtils,
+        ipRangeChecker,
+        cors,
+        telemetry,
+        dataEnrichment,
+        graphQLParser,
+        tokenParser,
+        riskApiClient,
+        activityClient,
+        logServiceClient,
+        remoteConfigStorageClient,
+        remoteConfigServiceClient,
+        remoteConfigUpdater,
+    };
+    const products = createEnforcerProducts(config, options.products, base64Utils, hashUtils, urlUtils, ipRangeChecker);
+    return { products, ...allOptions };
+};
+export const createEnforcerProducts = (config, products, base64Utils, hashUtils, urlUtils, ipRangeChecker) => {
+    const botDefender = products?.bd || new BotDefender(config, { base64Utils, ipRangeChecker, urlUtils });
+    const accountDefender = products?.ad || new AccountDefender(config, { base64Utils });
+    const credentialIntelligence = config.ciEnabled
+        ? products?.ci || new CredentialIntelligence(config, { hashUtils, urlUtils })
+        : null;
+    const hypeSaleChallenge = products?.hsc || new HypeSaleChallenge(config, { base64Utils });
+    return {
+        [ProductName.BOT_DEFENDER]: botDefender,
+        [ProductName.ACCOUNT_DEFENDER]: accountDefender,
+        [ProductName.CODE_DEFENDER]: products?.cd,
+        [ProductName.CREDENTIAL_INTELLIGENCE]: credentialIntelligence,
+        [ProductName.HYPE_SALE_CHALLENGE]: hypeSaleChallenge,
+    };
+};

package/lib/esm/impl/url/UrlImpl.js

@@ -51,6 +51,9 @@ export class UrlImpl {
     get searchParams() {
         return new UrlSearchParamsImpl(this.urlUtils, this.search);
     }
+    toJSON() {
+        return this.href;
+    }
     isDefaultPort(port) {
         const PROTOCOL_TO_DEFAULT_PORT = {
             'https:': '443',

package/lib/esm/products/credential_intelligence/endpoint/extractor/BodyCredentialExtractor.js

@@ -1,5 +1,5 @@
 import { CONTENT_TYPE_HEADER_NAME, ContentType } from '../../../../http';
-import { getPropertyFromObject } from '../../../../utils';
+import { EnforcerError, getPropertyFromObject } from '../../../../utils';
 export class BodyCredentialExtractor {
     userField;
     passField;
@@ -8,14 +8,12 @@ export class BodyCredentialExtractor {
         this.passField = passField;
     }
     async extractCredentials(request) {
-        try {
-            const contentType = request.headers.get(CONTENT_TYPE_HEADER_NAME);
-            const credentials = await this.extractFromBody(contentType, request);
-            return typeof credentials?.user === 'string' || typeof credentials?.pass === 'string' ? credentials : null;
-        }
-        catch (e) {
-            return null;
+        const contentType = request.headers.get(CONTENT_TYPE_HEADER_NAME);
+        if (!contentType) {
+            throw new EnforcerError('cannot extract credentials from body without content-type!');
         }
+        const credentials = await this.extractFromBody(contentType, request);
+        return typeof credentials?.user === 'string' || typeof credentials?.pass === 'string' ? credentials : null;
     }
     async extractFromBody(contentType, request) {
         if (contentType.includes('json')) {

package/lib/esm/products/credential_intelligence/endpoint/extractor/CustomCredentialExtractor.js

@@ -4,11 +4,6 @@ export class CustomCredentialExtractor {
         this.callback = callback;
     }
     async extractCredentials(request) {
-        try {
-            return await this.callback(request.getUnderlyingRequest());
-        }
-        catch (e) {
-            return null;
-        }
+        return this.callback(request.getUnderlyingRequest());
     }
 }

package/lib/esm/products/hype_sale_challenge/HypeSaleChallenge.js

@@ -66,7 +66,7 @@ export class HypeSaleChallenge {
         return customParameters?.[IS_HYPESALE_PARAM_NAME];
     }
     isTokenHscApproved({ tokenParseResult, token }) {
-        return tokenParseResult === TokenParseResult.SUCCESSFUL && token?.isValid() && token.cpa;
+        return tokenParseResult === TokenParseResult.SUCCESSFUL && token?.isValidated && token.cpa;
     }
     isRiskResponseHscApproved({ riskApiCallResult, riskResponse }) {
         return (riskApiCallResult === RiskApiCallResult.SUCCESSFUL &&

package/lib/esm/risk_api/risk_response/RiskResponseBase.js

@@ -41,4 +41,18 @@ export class RiskResponseBase {
     get drc() {
         return this.riskResponse?.drc;
     }
+    toJSON() {
+        return {
+            status: this.status,
+            action: this.action,
+            message: this.message,
+            dataEnrichment: this.dataEnrichment,
+            pxhd: this.pxhd,
+            pxhdDomain: this.pxhdDomain,
+            score: this.score,
+            drc: this.drc,
+            additionalRiskInfo: this.additionalRiskInfo,
+            uuid: this.uuid,
+        };
+    }
 }

package/lib/esm/risk_api/risk_response/index.js

@@ -3,3 +3,4 @@ export * from './RiskResponseBase';
 export * from './CommonRiskResponsePayload';
 export * from './v2';
 export * from './v3';
+export * from './serialize';

package/lib/esm/risk_api/risk_response/serialize/RiskResponseJson.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/risk_api/risk_response/serialize/SerializedRiskResponse.js

@@ -0,0 +1,27 @@
+export class SerializedRiskResponse {
+    action;
+    additionalRiskInfo;
+    dataEnrichment;
+    drc;
+    message;
+    pxhd;
+    pxhdDomain;
+    score;
+    status;
+    uuid;
+    constructor(riskResponseJson) {
+        this.action = riskResponseJson.action;
+        this.additionalRiskInfo = riskResponseJson.additionalRiskInfo;
+        this.dataEnrichment = riskResponseJson.dataEnrichment;
+        this.drc = riskResponseJson.drc;
+        this.message = riskResponseJson.message;
+        this.pxhd = riskResponseJson.pxhd;
+        this.pxhdDomain = riskResponseJson.pxhdDomain;
+        this.score = riskResponseJson.score;
+        this.status = riskResponseJson.status;
+        this.uuid = riskResponseJson.uuid;
+    }
+    validate() {
+        return true;
+    }
+}

package/lib/esm/risk_api/risk_response/serialize/index.js

@@ -0,0 +1,2 @@
+export * from './SerializedRiskResponse';
+export * from './RiskResponseJson';

package/lib/esm/risk_token/parser/TokenParserBase.js

@@ -78,7 +78,7 @@ export class TokenParserBase {
         }
         mobileData.originalTokenParseResult = await mobileData.originalToken.verify(context);
         if (mobileData.originalTokenParseResult === TokenParseResult.SUCCESSFUL) {
-            mobileData.decodedOriginalToken = mobileData.originalToken.getPayloadString();
+            mobileData.decodedOriginalToken = mobileData.originalToken.payloadString;
         }
     }
 }

package/lib/esm/risk_token/token/TokenBase.js

@@ -6,12 +6,13 @@ export class TokenBase {
     cookieSecret;
     cookieMaxLength;
     isValidated;
-    constructor(config, cookieString) {
+    constructor(config, cookieString, isValidated = false, payload) {
         this.config = config;
         this.cookieSecret = config.cookieSecret;
         this.cookieMaxLength = config.riskCookieMaxLength;
         this.cookieString = cookieString;
-        this.isValidated = false;
+        this.isValidated = isValidated;
+        this.payload = payload;
     }
     async verify(context) {
         if (!this.cookieString) {
@@ -36,10 +37,24 @@ export class TokenBase {
     isValid() {
         return this.isValidated;
     }
-    getTokenString() {
+    get tokenString() {
         return this.cookieString;
     }
-    getPayloadString() {
+    get payloadString() {
         return this.payload ? JSON.stringify(this.payload) : '';
     }
+    toJSON() {
+        return {
+            action: this.action,
+            cpa: this.cpa,
+            hmac: this.hmac,
+            isValidated: this.isValidated,
+            payloadString: this.payloadString,
+            score: this.score,
+            timestamp: this.timestamp,
+            tokenString: this.tokenString,
+            uuid: this.uuid,
+            vid: this.vid,
+        };
+    }
 }

package/lib/esm/risk_token/token/index.js

@@ -1,4 +1,5 @@
-export { TokenBase } from './TokenBase';
-export { DefaultTokenV2 } from './v2/DefaultTokenV2';
-export { DefaultTokenV3 } from './v3/DefaultTokenV3';
-export { TokenSignField } from './v3/TokenSignField';
+export * from './IToken';
+export * from './TokenBase';
+export * from './v2';
+export * from './v3';
+export * from './serialize';

package/lib/esm/risk_token/token/serialize/SerializedToken.js

@@ -0,0 +1,36 @@
+import { TokenParseResult } from '../../TokenParseResult';
+export class SerializedToken {
+    action;
+    cpa;
+    hmac;
+    isValidated;
+    payloadString;
+    score;
+    timestamp;
+    tokenString;
+    uuid;
+    vid;
+    blockingScore;
+    constructor(config, serializedToken) {
+        this.blockingScore = config.blockingScore;
+        this.action = serializedToken.action;
+        this.cpa = serializedToken.cpa;
+        this.hmac = serializedToken.hmac;
+        this.isValidated = serializedToken.isValidated;
+        this.payloadString = serializedToken.payloadString;
+        this.score = serializedToken.score;
+        this.timestamp = serializedToken.timestamp;
+        this.tokenString = serializedToken.tokenString;
+        this.uuid = serializedToken.uuid;
+        this.vid = serializedToken.vid;
+    }
+    isExpired() {
+        return Date.now() >= this.timestamp;
+    }
+    isHighScore() {
+        return this.score >= this.blockingScore;
+    }
+    verify(context) {
+        return TokenParseResult.NONE;
+    }
+}

package/lib/esm/risk_token/token/serialize/TokenJson.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/risk_token/token/serialize/index.js

@@ -0,0 +1,2 @@
+export * from './SerializedToken';
+export * from './TokenJson';

package/lib/esm/risk_token/token/v2/index.js

@@ -0,0 +1,2 @@
+export * from './TokenV2Payload';
+export * from './DefaultTokenV2';

package/lib/esm/risk_token/token/v3/DefaultTokenV3.js

@@ -9,8 +9,8 @@ export class DefaultTokenV3 extends TokenBase {
     cipherUtils;
     hmacUtils;
     hash;
-    constructor(config, cookieString, cipherUtils, hmacUtils) {
-        super(config, cookieString);
+    constructor(config, cookieString, cipherUtils, hmacUtils, isValidated = false, payload) {
+        super(config, cookieString, isValidated, payload);
         this.maxIterations = config.riskCookieMaxIterations;
         this.minIterations = config.riskCookieMinIterations;
         this.blockingScore = config.blockingScore;

package/lib/esm/risk_token/token/v3/index.js

@@ -0,0 +1,3 @@
+export * from './DefaultTokenV3';
+export * from './TokenV3Payload';
+export * from './TokenSignField';

package/lib/esm/utils/constants.js

@@ -10,4 +10,4 @@ export const PUSH_DATA_HMAC_HEADER_NAME = 'x-px-pushdata';
 export const PUSH_DATA_FEATURE_HEADER_NAME = 'x-px-feature';
 export const EMAIL_ADDRESS_REGEX = /^[a-zA-Z0-9_+&*-]+(?:\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,7}$/;
 export const URL_REGEX = /^(https?\:)\/\/(([^@\s:]+):?([^@\s]*)@)?(([^:\/?#]*)(?:\:([0-9]+))?)([\/]{0,1}[^?#]*)(\?[^#]*|)(#.*|)$/;
-export const CORE_MODULE_VERSION = 'JS Core 0.16.1';
+export const CORE_MODULE_VERSION = 'JS Core 0.18.0';

package/lib/esm/utils/cookie_parser/StringSplitCookieParser.js

@@ -1,10 +1,23 @@
 export class StringSplitCookieParser {
-    parseCookies(cookieHeaderValue) {
+    cookieDelimiter;
+    constructor(cookieDelimiter = ';') {
+        this.cookieDelimiter = cookieDelimiter;
+    }
+    parseCookies(...cookieHeaderValues) {
+        const cookies = {};
+        if (!cookieHeaderValues) {
+            return cookies;
+        }
+        cookieHeaderValues.forEach((value) => {
+            Object.assign(cookies, this.parseCookieHeaderValue(value));
+        });
+        return cookies;
+    }
+    parseCookieHeaderValue(cookieHeaderValue) {
         if (!cookieHeaderValue || typeof cookieHeaderValue !== 'string') {
             return {};
         }
-        const COOKIE_DELIMITER = ';';
-        const cookieEntries = cookieHeaderValue.split(COOKIE_DELIMITER).map(this.getCookieParts).filter(Boolean);
+        const cookieEntries = cookieHeaderValue.split(this.cookieDelimiter).map(this.getCookieParts).filter(Boolean);
         const cookies = {};
         cookieEntries.forEach(([cookieName, cookieValue]) => {
             cookies[cookieName] = cookieValue;

package/lib/types/activities/HttpActivityClient.d.ts

@@ -10,6 +10,12 @@ export declare class HttpActivityClient<Req, Res> implements IActivityClient<Req
     constructor(config: IConfiguration<Req, Res>, httpClient: IHttpClient);
     sendActivities(context: ReadonlyContext<Req, Res>): Promise<boolean>;
     protected createActivities(context: ReadonlyContext<Req, Res>): AsyncActivity[];
+    protected shouldCreateBlockActivity(context: ReadonlyContext<Req, Res>): boolean;
+    protected shouldCreatePageRequestedActivity(context: ReadonlyContext<Req, Res>): boolean;
+    protected shouldCreateAdditionalS2SActivity(context: ReadonlyContext<Req, Res>): boolean;
+    protected createBlockActivity(context: ReadonlyContext<Req, Res>): AsyncActivity;
+    protected createPageRequestedActivity(context: ReadonlyContext<Req, Res>): AsyncActivity;
+    protected createAdditionalS2SActivity(context: ReadonlyContext<Req, Res>): AsyncActivity;
     /**
      * Allows for expansions or alterations to the async activity if needed.
      * @param activity