perimeterx-js-core 0.7.1 → 0.9.0

package/lib/esm/activities/HttpActivityClient.js

@@ -0,0 +1,59 @@
+import { Action } from '../action';
+import { AUTHORIZATION_HEADER_NAME, CONTENT_TYPE_HEADER_NAME, ContentType, HttpMethod, OutgoingRequestImpl, } from '../http';
+import { getAuthorizationHeader } from '../utils';
+import { ActivityType } from './ActivityType';
+import { createAsyncActivity } from './utils';
+import { ACTIVITIES_ENDPOINT } from './constants';
+export class HttpActivityClient {
+    config;
+    httpClient;
+    constructor(config, httpClient) {
+        this.config = config;
+        this.httpClient = httpClient;
+    }
+    async sendActivities(context) {
+        try {
+            const activities = this.createActivities(context);
+            return await this.postActivities(activities);
+        }
+        catch (e) {
+            this.config.logger.error(`unable to send activities - ${e}`);
+            return false;
+        }
+    }
+    createActivities(context) {
+        const activities = [];
+        if (context.action === Action.BLOCK || context.action === Action.SIMULATED_BLOCK) {
+            activities.push(createAsyncActivity(ActivityType.BLOCK, this.config, context));
+        }
+        else if (context.action === Action.PASS_REQUEST) {
+            activities.push(createAsyncActivity(ActivityType.PAGE_REQUESTED, this.config, context));
+            if (context.productData.ci && this.config.ciAutomaticAdditionalS2SEnabled) {
+                activities.push(createAsyncActivity(ActivityType.ADDITIONAL_S2S, this.config, context));
+            }
+        }
+        return activities.map(this.finalizeActivity);
+    }
+    /**
+     * Allows for expansions or alterations to the async activity if needed.
+     * @param activity
+     * @returns AsyncActivity
+     * @protected
+     */
+    finalizeActivity(activity) {
+        return activity;
+    }
+    async postActivities(activities) {
+        const url = `${this.config.backendCollectorUrl}${ACTIVITIES_ENDPOINT}`;
+        const method = HttpMethod.POST;
+        const headers = {
+            [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
+            [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.config.authToken)],
+        };
+        const body = activities.length === 1 ? JSON.stringify(activities[0]) : JSON.stringify(activities);
+        this.config.logger.debug(`sending ${activities.map(({ type }) => `${type} activity`).join(', ')} to ${url}`);
+        const req = new OutgoingRequestImpl({ url, method, headers, body });
+        const res = await this.httpClient.send(req);
+        return res?.status === 200;
+    }
+}

package/lib/esm/activities/HttpBatchedActivityClient.js

@@ -0,0 +1,55 @@
+import { HttpActivityClient } from './HttpActivityClient';
+export class HttpBatchedActivityClient extends HttpActivityClient {
+    batchSize;
+    timeoutMs;
+    maxBufferSize;
+    buffer;
+    timeoutId;
+    constructor(config, httpClient) {
+        super(config, httpClient);
+        this.buffer = [];
+        this.batchSize = config.maxActivityBatchSize;
+        this.timeoutMs = config.activityBatchTimeoutMs;
+        this.maxBufferSize = this.batchSize * 2;
+        this.startTimer();
+    }
+    stop() {
+        this.stopTimer();
+    }
+    async postActivities(activities) {
+        this.addToBuffer(activities);
+        return this.shouldFlush() ? this.triggerFlush() : true;
+    }
+    addToBuffer(activities) {
+        this.buffer = activities.concat(this.buffer);
+        if (this.buffer.length > this.maxBufferSize) {
+            this.buffer = this.buffer.slice(0, this.maxBufferSize);
+        }
+    }
+    shouldFlush() {
+        return this.buffer.length >= this.batchSize;
+    }
+    async triggerFlush() {
+        this.stopTimer();
+        const sentSuccessfully = this.buffer.length > 0 && (await this.flush());
+        this.startTimer();
+        return sentSuccessfully;
+    }
+    async flush() {
+        const sentSuccessfully = await super.postActivities(this.buffer);
+        if (sentSuccessfully) {
+            this.clear();
+        }
+        return sentSuccessfully;
+    }
+    clear() {
+        this.buffer = [];
+    }
+    startTimer() {
+        this.timeoutId = setTimeout(() => this.triggerFlush(), this.timeoutMs);
+    }
+    stopTimer() {
+        clearTimeout(this.timeoutId);
+        this.timeoutId = null;
+    }
+}

package/lib/esm/activities/model/index.js

@@ -0,0 +1,4 @@
+export * from './AsyncActivity';
+export * from './AsyncActivityDetails';
+export * from './HeaderEntry';
+export * from './CommonActivityDetails';

package/lib/esm/activities/utils.js

@@ -0,0 +1,190 @@
+import { ModuleMode, removeSensitiveHeaders, transferExistingProperties } from '../utils';
+import { ProductName } from '../products';
+import { BLOCK_ACTION_TO_PRODUCT_MAP } from '../blocker';
+import { Action } from '../action';
+import { ActivityType } from './ActivityType';
+import { TokenParseResult } from '../risk_token';
+export const createAsyncActivity = (activityType, config, context) => {
+    return {
+        type: activityType,
+        px_app_id: config.appId,
+        url: context.requestData.rawUrl,
+        headers: activityType !== ActivityType.ADDITIONAL_S2S
+            ? toHeaderEntryArray(removeSensitiveHeaders(context.requestData.headers, config.sensitiveHeaders))
+            : undefined,
+        pxhd: context.pxhd?.value,
+        socket_ip: context.requestData.ip,
+        timestamp: Date.now(),
+        vid: context.vid,
+        details: createActivityDetails(activityType, config, context),
+    };
+};
+export const createActivityDetails = (activityType, config, context) => {
+    const commonActivityDetails = createCommonActivityDetails(config, context);
+    const commonAsyncActivityDetails = createAsyncActivityCommonDetails(context);
+    let specificActivityDetails = {};
+    switch (activityType) {
+        case ActivityType.PAGE_REQUESTED:
+            specificActivityDetails = createPageRequestedActivityDetails(context);
+            break;
+        case ActivityType.BLOCK:
+            specificActivityDetails = createBlockActivityDetails(context);
+            break;
+        case ActivityType.ADDITIONAL_S2S:
+            specificActivityDetails = createAdditionalS2SActivityDetails(config, context);
+            break;
+    }
+    return Object.assign(commonActivityDetails, commonAsyncActivityDetails, specificActivityDetails);
+};
+export const createAsyncActivityCommonDetails = (context) => {
+    const details = {
+        client_uuid: context.uuid,
+    };
+    addRiskApiDataToAsyncActivityCommonDetails(details, context);
+    addResponseDataToAsyncActivityCommonDetails(details, context);
+    return details;
+};
+export const createCommonActivityDetails = (config, context) => {
+    const details = {
+        module_version: config.moduleVersion,
+        // Note: risk_mode currently reflects only Bot Defender mode
+        risk_mode: context.productData.bd?.isMonitoredRequest ? ModuleMode.MONITOR : ModuleMode.ACTIVE_BLOCKING,
+    };
+    addRootContextDataToDetails(details, context);
+    addRequestDataToDetails(details, context.requestData);
+    addTokenDataToDetails(details, context.tokenData);
+    addProductDataToDetails(details, context.productData);
+    addServerDataToDetails(details, context.serverData);
+    addTlsDataToDetails(details, context.tlsData);
+    addCustomParametersToDetails(details, context.customParameters);
+    return details;
+};
+export const addRootContextDataToDetails = (details, context) => {
+    transferExistingProperties(context, details, {
+        requestId: 'request_id',
+        tokenOrigin: 'cookie_origin',
+        vidSource: 'enforcer_vid_source',
+        graphqlData: 'graphql_operations',
+    });
+};
+export const addCustomParametersToDetails = (details, customParameters) => {
+    if (customParameters) {
+        Object.assign(details, customParameters);
+    }
+};
+export const addProductDataToDetails = (details, productData) => {
+    transferExistingProperties(productData.ad, details, {
+        appUserId: 'app_user_id',
+        additionalFields: 'jwt_additional_fields',
+        crossTabSession: 'cross_tab_session',
+    });
+    transferExistingProperties(productData.ci, details, {
+        hashedUsername: 'user',
+        hashedPassword: 'pass',
+        ciVersion: 'ci_version',
+        ssoStep: 'sso_step',
+    });
+};
+export const addTlsDataToDetails = (details, tlsData) => {
+    transferExistingProperties(tlsData, details, {
+        tlsProtocol: 'tls_protocol',
+        tlsServer: 'tls_server',
+        tlsCipher: 'tls_cipher',
+        tlsCiphersSha: 'tls_ciphers_sha',
+        tlsExtensionSha: 'tls_extension_sha',
+        tlsPreferredCiphers: 'tls_preferred_ciphers',
+        tlsJa3Fingerprint: 'tls_ja3_fingerprint',
+    });
+};
+export const addServerDataToDetails = (details, serverData) => {
+    transferExistingProperties(serverData, details, {
+        region: 'server_info_region',
+        datacenter: 'server_info_datacenter',
+    });
+};
+export const addRequestDataToDetails = (details, requestData) => {
+    transferExistingProperties(requestData, details, {
+        httpVersion: 'http_version',
+        method: 'http_method',
+        requestCookieNames: 'request_cookie_names',
+    });
+};
+export const addTokenDataToDetails = (details, { token, mobileData }) => {
+    if (token) {
+        if (token.isValid()) {
+            details.px_cookie = token.getPayloadString();
+            details.px_cookie_hmac = token.hmac;
+        }
+        else {
+            details.px_orig_cookie = token.getTokenString();
+        }
+    }
+    if (mobileData) {
+        transferExistingProperties(mobileData, details, {
+            originalToken: 'original_token',
+            decodedOriginalToken: 'px_decoded_original_token',
+        });
+        if (mobileData.originalTokenParseResult === TokenParseResult.DECRYPTION_FAILED) {
+            details.original_token_error = 'cookie_decryption_failed';
+        }
+        else if (mobileData.originalTokenParseResult === TokenParseResult.VALIDATION_FAILED) {
+            details.original_token_error = 'cookie_validation_failed';
+        }
+    }
+};
+export const addRiskApiDataToAsyncActivityCommonDetails = (details, context) => {
+    transferExistingProperties(context.riskApiData, details, {
+        riskRtt: 'risk_rtt',
+        s2sCallReason: 's2s_call_reason',
+    });
+    if (context.riskApiData.riskResponse?.additionalRiskInfo) {
+        details.additional_risk_info = context.riskApiData.riskResponse.additionalRiskInfo;
+    }
+    if (context.productData[ProductName.CREDENTIAL_INTELLIGENCE]) {
+        details.credentials_compromised = context.productData[ProductName.CREDENTIAL_INTELLIGENCE].isCompromised;
+    }
+};
+export const addResponseDataToAsyncActivityCommonDetails = (details, context) => {
+    transferExistingProperties(context.response, details, {
+        status: 'http_status_code',
+    });
+};
+export const createPageRequestedActivityDetails = (context) => {
+    const details = {};
+    details.pass_reason = Object.values(context.reasons)
+        .filter((x) => x)
+        .join(', ');
+    transferExistingProperties(context.riskApiData, details, {
+        errorReason: 's2s_error_reason',
+        errorHttpStatus: 's2s_error_http_status',
+        errorMessage: 'error_message',
+    });
+    return details;
+};
+export const createBlockActivityDetails = (context) => {
+    const details = {};
+    const blockingProduct = BLOCK_ACTION_TO_PRODUCT_MAP.get(context.blockAction);
+    details.block_reason = context.reasons?.[blockingProduct];
+    details.simulated_block = context.action === Action.SIMULATED_BLOCK;
+    transferExistingProperties(context, details, {
+        blockAction: 'block_action',
+        score: 'block_score',
+    });
+    return details;
+};
+export const createAdditionalS2SActivityDetails = ({ ciSendRawUsernameOnAdditionalS2SActivity }, { productData }) => {
+    const { rawUsername, isCompromised, isLoginSuccessful } = productData.ci;
+    const details = { login_successful: isLoginSuccessful };
+    if (isCompromised &&
+        ciSendRawUsernameOnAdditionalS2SActivity &&
+        (isLoginSuccessful || typeof isLoginSuccessful !== 'boolean')) {
+        details.raw_username = rawUsername;
+    }
+    return details;
+};
+export const toHeaderEntryArray = (headers) => {
+    return Object.entries(headers).flatMap(([key, values]) => values.map((value) => ({
+        name: key,
+        value: value,
+    })));
+};

package/lib/esm/additional_activity_handler/AdditionalActivityHandlerUtils.js

@@ -0,0 +1,14 @@
+export var AdditionalActivityHandlerUtils;
+(function (AdditionalActivityHandlerUtils) {
+    AdditionalActivityHandlerUtils.invokeAdditionalActivityHandler = async (config, context) => {
+        if (config.additionalActivityHandler && typeof config.additionalActivityHandler === 'function') {
+            try {
+                config.logger.debug('calling additional activity handler');
+                await config.additionalActivityHandler(config.toParams(), context, context.requestData.request.getUnderlyingRequest());
+            }
+            catch (e) {
+                config.logger.error(`caught additional activity handler error - ${e}`);
+            }
+        }
+    };
+})(AdditionalActivityHandlerUtils || (AdditionalActivityHandlerUtils = {}));

package/lib/esm/config/StaticConfigurationBase.js

@@ -0,0 +1,280 @@
+import { DEFAULT_CONFIGURATIONS } from './DefaultConfigurations';
+import { LoggerSeverity, DefaultLogger } from '../logger';
+import { ModuleMode, getScoreApiDomain, getCollectorDomain, isValidEnumValue, EnforcerError, CORE_MODULE_VERSION, } from '../utils';
+export class StaticConfigurationBase {
+    configParams;
+    internalLogger;
+    constructor(params, defaultParams) {
+        this.configParams = this.initialize(params, { ...DEFAULT_CONFIGURATIONS, ...defaultParams });
+        this.internalLogger = new DefaultLogger(this.configParams.px_logger_severity);
+    }
+    initialize(params, defaultParams) {
+        this.throwIfMissingRequiredField(params);
+        const config = {};
+        Object.keys(defaultParams).forEach((k) => {
+            config[k] = this.getValidConfigValue(params, defaultParams, k);
+        });
+        return config;
+    }
+    throwIfMissingRequiredField(params) {
+        const REQUIRED_FIELDS = ['px_app_id', 'px_cookie_secret', 'px_auth_token'];
+        REQUIRED_FIELDS.forEach((key) => {
+            if (!params[key]) {
+                throw new EnforcerError(`${String(key)} cannot be empty!`);
+            }
+        });
+    }
+    getValidConfigValue(params, defaultParams, key) {
+        if (params[key] != null && this.isValidConfigValue(params, defaultParams, key)) {
+            return params[key];
+        }
+        else {
+            return this.getDefaultConfigurationValue(params, defaultParams, key);
+        }
+    }
+    isValidConfigValue(params, defaultParams, key) {
+        switch (key) {
+            case 'px_logger_severity':
+                return isValidEnumValue(LoggerSeverity, params[key]);
+            case 'px_module_mode':
+                return isValidEnumValue(ModuleMode, params[key]);
+            default:
+                if (defaultParams[key] === null) {
+                    return typeof params[key] === 'function';
+                }
+                if (Array.isArray(defaultParams[key])) {
+                    return Array.isArray(params[key]);
+                }
+                return typeof params[key] === typeof defaultParams[key];
+        }
+    }
+    getDefaultConfigurationValue(params, defaultParams, key) {
+        switch (key) {
+            case 'px_backend_url':
+                return `https://${getScoreApiDomain(params.px_app_id)}`;
+            case 'px_backend_collector_url':
+                return `https://${getCollectorDomain(params.px_app_id)}`;
+            default:
+                return defaultParams[key];
+        }
+    }
+    toParams() {
+        return Object.assign({}, this.configParams);
+    }
+    get moduleVersion() {
+        return `${this.getModuleVersion()} (${CORE_MODULE_VERSION})`;
+    }
+    get logger() {
+        return this.internalLogger;
+    }
+    get appId() {
+        return this.configParams.px_app_id;
+    }
+    get authToken() {
+        return this.configParams.px_auth_token;
+    }
+    get blockingScore() {
+        return this.configParams.px_blocking_score;
+    }
+    get bypassMonitorHeader() {
+        return this.configParams.px_bypass_monitor_header;
+    }
+    get cookieSecret() {
+        return this.configParams.px_cookie_secret;
+    }
+    get customCookieHeader() {
+        return this.configParams.px_custom_cookie_header;
+    }
+    get customLogo() {
+        return this.configParams.px_custom_logo;
+    }
+    get enforcedRoutes() {
+        return this.configParams.px_enforced_routes;
+    }
+    get filteredExtensions() {
+        return this.configParams.px_filter_by_extension.map((ext) => (ext.startsWith('.') ? ext : `.${ext}`));
+    }
+    get filteredHttpMethods() {
+        return this.configParams.px_filter_by_http_method;
+    }
+    get filteredIps() {
+        return this.configParams.px_filter_by_ip;
+    }
+    get filteredRoutes() {
+        return this.configParams.px_filter_by_route;
+    }
+    get filteredUserAgents() {
+        return this.configParams.px_filter_by_user_agent;
+    }
+    get firstPartyEnabled() {
+        return this.configParams.px_first_party_enabled;
+    }
+    get customFirstPartyPrefix() {
+        return this.configParams.px_custom_first_party_prefix;
+    }
+    get customFirstPartySensorEndpoint() {
+        return this.configParams.px_custom_first_party_sensor_endpoint;
+    }
+    get customFirstPartyXhrEndpoint() {
+        return this.configParams.px_custom_first_party_xhr_endpoint;
+    }
+    get customFirstPartyCaptchaEndpoint() {
+        return this.configParams.px_custom_first_party_captcha_endpoint;
+    }
+    get loggerSeverity() {
+        return this.logger.getLoggerSeverity();
+    }
+    get moduleEnabled() {
+        return this.configParams.px_module_enabled;
+    }
+    get moduleMode() {
+        return this.configParams.px_module_mode;
+    }
+    get monitoredRoutes() {
+        return this.configParams.px_monitored_routes;
+    }
+    get s2sTimeout() {
+        return this.configParams.px_s2s_timeout;
+    }
+    get sensitiveHeaders() {
+        return this.configParams.px_sensitive_headers;
+    }
+    get sensitiveRoutes() {
+        return this.configParams.px_sensitive_routes;
+    }
+    get advancedBlockingResponseEnabled() {
+        return this.configParams.px_advanced_blocking_response_enabled;
+    }
+    get backendScoreApiUrl() {
+        return this.configParams.px_backend_url;
+    }
+    get ipHeaders() {
+        return this.configParams.px_ip_headers;
+    }
+    get backendCaptchaUrl() {
+        return this.configParams.px_backend_captcha_url;
+    }
+    get backendClientUrl() {
+        return this.configParams.px_backend_client_url;
+    }
+    get backendCollectorUrl() {
+        return this.configParams.px_backend_collector_url;
+    }
+    get cssRef() {
+        return this.configParams.px_css_ref;
+    }
+    get jsRef() {
+        return this.configParams.px_js_ref;
+    }
+    get riskCookieMaxIterations() {
+        return this.configParams.px_risk_cookie_max_iterations;
+    }
+    get riskCookieMinIterations() {
+        return this.configParams.px_risk_cookie_min_iterations;
+    }
+    get riskCookieMaxLength() {
+        return this.configParams.px_risk_cookie_max_length;
+    }
+    get userAgentMaxLength() {
+        return this.configParams.px_user_agent_max_length;
+    }
+    get maxActivityBatchSize() {
+        return this.configParams.px_max_activity_batch_size;
+    }
+    get activityBatchTimeoutMs() {
+        return this.configParams.px_batch_activities_timeout_ms;
+    }
+    get graphqlEnabled() {
+        return this.configParams.px_graphql_enabled;
+    }
+    get graphqlRoutes() {
+        return this.configParams.px_graphql_routes;
+    }
+    get sensitiveGraphqlOperationNames() {
+        return this.configParams.px_sensitive_graphql_operation_names;
+    }
+    get sensitiveGraphqlOperationTypes() {
+        return this.configParams.px_sensitive_graphql_operation_types;
+    }
+    get enrichCustomParameters() {
+        return this.configParams.px_enrich_custom_parameters || null;
+    }
+    get additionalActivityHandler() {
+        return this.configParams.px_additional_activity_handler || null;
+    }
+    get altBackendCaptchaUrl() {
+        return 'https://captcha.px-cloud.net';
+    }
+    get corsSupportEnabled() {
+        return this.configParams.px_cors_support_enabled;
+    }
+    get corsCustomPreflightHandler() {
+        return this.configParams.px_cors_custom_preflight_handler || null;
+    }
+    get corsPreflightRequestFilterEnabled() {
+        return this.configParams.px_cors_preflight_request_filter_enabled;
+    }
+    get corsCreateCustomBlockResponseHeaders() {
+        return this.configParams.px_cors_create_custom_block_response_headers || null;
+    }
+    get jwtCookieAdditionalFieldNames() {
+        return this.configParams.px_jwt_cookie_additional_field_names;
+    }
+    get jwtCookieName() {
+        return this.configParams.px_jwt_cookie_name;
+    }
+    get jwtCookieUserIdFieldName() {
+        return this.configParams.px_jwt_cookie_user_id_field_name;
+    }
+    get jwtHeaderAdditionalFieldNames() {
+        return this.configParams.px_jwt_header_additional_field_names;
+    }
+    get jwtHeaderName() {
+        return this.configParams.px_jwt_header_name;
+    }
+    get jwtHeaderUserIdFieldName() {
+        return this.configParams.px_jwt_header_user_id_field_name;
+    }
+    get ciEnabled() {
+        return this.configParams.px_login_credentials_extraction_enabled;
+    }
+    get loggerAuthToken() {
+        return this.configParams.px_logger_auth_token;
+    }
+    get ciEndpoints() {
+        return this.configParams.px_login_credentials_extraction;
+    }
+    get ciCompromisedCredentialsHeaderName() {
+        return this.configParams.px_compromised_credentials_header;
+    }
+    get ciSendRawUsernameOnAdditionalS2SActivity() {
+        return this.configParams.px_send_raw_username_on_additional_s2s_activity;
+    }
+    get ciAutomaticAdditionalS2SEnabled() {
+        return this.configParams.px_automatic_additional_s2s_activity_enabled;
+    }
+    get ciAdditionalS2SHeaderEnabled() {
+        return this.configParams.px_additional_s2s_activity_header_enabled;
+    }
+    get ciDefaultVersion() {
+        return this.configParams.px_credentials_intelligence_version;
+    }
+    get ciDefaultLoginSuccessfulReportingMethod() {
+        return this.configParams.px_login_successful_reporting_method;
+    }
+    get ciDefaultLoginSuccessfulStatus() {
+        return this.configParams.px_login_successful_status;
+    }
+    get ciDefaultLoginSuccessfulBodyRegex() {
+        return this.configParams.px_login_successful_body_regex;
+    }
+    get ciDefaultLoginSuccessfulHeaderName() {
+        return this.configParams.px_login_successful_header_name;
+    }
+    get ciDefaultLoginSuccessfulHeaderValue() {
+        return this.configParams.px_login_successful_header_value;
+    }
+    get ciDefaultLoginSuccessfulCustomCallback() {
+        return this.configParams.px_login_successful_custom_callback;
+    }
+}