perimeterx-js-core 0.7.1 → 0.9.0

package/lib/esm/http/utils/URLUtils.js

@@ -0,0 +1,62 @@
+import { UrlImpl } from './UrlImpl';
+import { UrlSearchParamsImpl } from './UrlSearchParamsImpl';
+export var URLUtils;
+(function (URLUtils) {
+    URLUtils.parseURL = (rawUrl) => {
+        return global?.URL ? new URL(rawUrl) : new UrlImpl(rawUrl);
+    };
+    URLUtils.parseSearchParams = (search) => {
+        return global?.URLSearchParams ? new URLSearchParams(search) : new UrlSearchParamsImpl(search);
+    };
+    URLUtils.decodeUriComponent = (input) => {
+        return global?.decodeURIComponent ? decodeURIComponent(input) : decodeUriComponentPolyfill(input);
+    };
+    URLUtils.encodeUriComponent = (input) => {
+        return global?.encodeURIComponent ? encodeURIComponent(input) : encodeUriComponentPolyfill(input);
+    };
+    const decodeUriComponentPolyfill = (input) => {
+        // https://www.npmjs.com/package/as-uri-encode-decode
+        // Note: Does not work well with multibyte characters
+        let result = '';
+        for (let i = 0; i < input.length; i++) {
+            if (input.charAt(i) === '+') {
+                result += ' ';
+                continue;
+            }
+            if (input.charAt(i) === '%' && input.charAt(i + 1) !== '%' && input.charAt(i + 2) !== '%') {
+                const charCode = parseInt(input.charAt(i + 1) + input.charAt(i + 2), 16);
+                const char = String.fromCharCode(charCode);
+                result += char;
+                i += 2;
+                continue;
+            }
+            result += input.charAt(i);
+        }
+        return result;
+    };
+    const encodeUriComponentPolyfill = (input) => {
+        // https://www.npmjs.com/package/as-uri-encode-decode
+        // Note: Does not work well with multibyte characters
+        let result = '';
+        for (let i = 0; i < input.length; i++) {
+            const c = input.charAt(i);
+            if (isSafe(c)) {
+                result += c;
+            }
+            else {
+                result += '%' + c.charCodeAt(0).toString(16).toUpperCase();
+            }
+        }
+        return result;
+    };
+    const isSafe = (c) => {
+        return ((c >= 'a' && c <= 'z') ||
+            (c >= 'A' && c <= 'Z') ||
+            (c >= '0' && c <= '9') ||
+            c == '-' ||
+            c == '_' ||
+            c == '.' ||
+            c == '*' ||
+            c == '!');
+    };
+})(URLUtils || (URLUtils = {}));

package/lib/esm/http/utils/UrlImpl.js

@@ -0,0 +1,54 @@
+import { URL_REGEX } from '../../utils';
+import { URLUtils } from './URLUtils';
+export class UrlImpl {
+    protocol;
+    hostname;
+    pathname;
+    search;
+    hash;
+    _port;
+    constructor(rawUrl) {
+        const match = rawUrl.match(URL_REGEX);
+        if (!match) {
+            throw new Error(`Invalid UrlImpl: ${rawUrl}`);
+        }
+        this.protocol = match[1];
+        this.hostname = match[3];
+        this.port = match[4] || '';
+        this.pathname = match[5] || '/';
+        this.search = match[6] || '';
+        this.hash = match[7] || '';
+    }
+    get href() {
+        return `${this.origin}${this.pathname}${this.search}${this.hash}`;
+    }
+    get origin() {
+        return `${this.protocol}//${this.host}`;
+    }
+    get host() {
+        return `${this.hostname}${this.port ? `:${this.port}` : ''}`;
+    }
+    set host(newHost) {
+        const [host, port] = newHost.split(':');
+        this.hostname = host;
+        this.port = port;
+    }
+    get port() {
+        return this._port;
+    }
+    set port(port) {
+        if (port) {
+            this._port = this.isDefaultPort(port) ? '' : port;
+        }
+    }
+    get searchParams() {
+        return URLUtils.parseSearchParams(this.search);
+    }
+    isDefaultPort(port) {
+        const PROTOCOL_TO_DEFAULT_PORT = {
+            'https:': '443',
+            'http:': '80',
+        };
+        return PROTOCOL_TO_DEFAULT_PORT[this.protocol] === port;
+    }
+}

package/lib/esm/http/utils/UrlSearchParamsImpl.js

@@ -0,0 +1,116 @@
+// This file is based on the implementation found here:
+// https://github.com/pinglu85/BFEdevSolutions/blob/main/Coding-Problems/80.implement-your-own-URLSearchParams.md
+import { URLUtils } from './URLUtils';
+export class UrlSearchParamsImpl {
+    _searchParamsArray;
+    _searchParamsMap;
+    constructor(init) {
+        this._searchParamsArray = [];
+        this._searchParamsMap = new Map();
+        if (init) {
+            if (typeof init !== 'object') {
+                this._constructSearchParamsFromString(init);
+            }
+            else if (Array.isArray(init)) {
+                this._constructSearchParamsFromArray(init);
+            }
+            else {
+                this._constructSearchParamsFromObject(init);
+            }
+        }
+    }
+    append(name, value) {
+        name = String(name);
+        value = String(value);
+        this._saveParam(name, value);
+    }
+    delete(name) {
+        name = String(name);
+        this._searchParamsMap.delete(name);
+        this._searchParamsArray = this._searchParamsArray.filter((param) => param[0] !== name);
+    }
+    forEach(callback) {
+        this._searchParamsArray.forEach((param) => {
+            callback(param[1], param[0], this);
+        });
+    }
+    get(name) {
+        name = String(name);
+        const value = this._searchParamsMap.get(name);
+        return value ? value[0] : null;
+    }
+    getAll(name) {
+        name = String(name);
+        const value = this._searchParamsMap.get(name);
+        return value ? value : [];
+    }
+    has(name) {
+        name = String(name);
+        return this._searchParamsMap.has(name);
+    }
+    set(name, value) {
+        name = String(name);
+        value = String(value);
+        if (!this.has(name)) {
+            this.append(name, value);
+            return;
+        }
+        name = URLUtils.decodeUriComponent(name);
+        value = URLUtils.decodeUriComponent(value);
+        this._searchParamsMap.set(name, [value]);
+        const searchParamIdx = this._searchParamsArray.findIndex((param) => param[0] === name);
+        this._searchParamsArray[searchParamIdx][1] = value;
+        this._searchParamsArray = this._searchParamsArray.filter((param, idx) => param[0] !== name || idx === searchParamIdx);
+    }
+    toString() {
+        return this._searchParamsArray
+            .map(([key, value]) => `${URLUtils.encodeUriComponent(key)}=${URLUtils.encodeUriComponent(value)}`)
+            .join('&');
+    }
+    _constructSearchParamsFromString(init) {
+        let searchParams = String(init);
+        if (searchParams.startsWith('?')) {
+            searchParams = searchParams.slice(1);
+        }
+        searchParams.split('&').forEach((param) => {
+            let [key, value] = param.split('=');
+            if (!value) {
+                value = '';
+            }
+            this._saveParam(key, value);
+        });
+    }
+    _constructSearchParamsFromArray(init) {
+        for (const param of init) {
+            if (!Array.isArray(param || param.length !== 2)) {
+                throw new Error("Failed to construct 'UrlSearchParamsImpl'");
+            }
+            const key = String(param[0]);
+            const value = String(param[1]);
+            this._saveParam(key, value);
+        }
+    }
+    _constructSearchParamsFromObject(init) {
+        if (init instanceof Set) {
+            throw new Error("Failed to construct 'UrlSearchParamsImpl'");
+        }
+        for (const key of Object.keys(init)) {
+            const value = String(init[key]);
+            this._saveParam(key, value);
+        }
+    }
+    _saveParam(key, value) {
+        key = URLUtils.decodeUriComponent(key);
+        value = URLUtils.decodeUriComponent(value);
+        this._searchParamsArray.push([key, value]);
+        this._storeParamInSearchParamsMap(key, value);
+    }
+    _storeParamInSearchParamsMap(key, value) {
+        let values = this._searchParamsMap.get(key);
+        if (!values) {
+            values = [];
+            this._searchParamsMap.set(key, values);
+        }
+        values.push(value);
+    }
+}

package/lib/esm/http/utils/index.js

@@ -0,0 +1,11 @@
+export * from './ContentType';
+export * from './constants';
+export * from './HttpMethod';
+export * from './MinimalResponseUtils';
+export * from './MultipartFormDataUtils';
+export * from './FormDataImpl';
+export * from './MinimalResponseImpl';
+export * from './OutgoingRequestImpl';
+export * from './UrlImpl';
+export * from './UrlSearchParamsImpl';
+export * from './URLUtils';

package/lib/esm/impl/base64/BufferBase64Utils.js

@@ -0,0 +1,11 @@
+export class BufferBase64Utils {
+    static BASE_64_ENCODING = 'base64';
+    base64Decode(stringToDecode) {
+        const buffer = Buffer.from(stringToDecode, BufferBase64Utils.BASE_64_ENCODING);
+        return buffer.toString('utf8');
+    }
+    base64Encode(stringToEncode) {
+        const buffer = Buffer.from(stringToEncode, 'utf8');
+        return buffer.toString(BufferBase64Utils.BASE_64_ENCODING);
+    }
+}

package/lib/esm/impl/cipher/CryptoCipherUtils.js

@@ -0,0 +1,18 @@
+import * as crypto from 'crypto';
+export class CryptoCipherUtils {
+    crypto;
+    constructor(cryptoModule = crypto) {
+        this.crypto = cryptoModule;
+    }
+    async pbkdf2Decrypt(secret, encryptedString, iterations, salt, options) {
+        const keylen = options?.keylen || 32;
+        const ivlen = options?.ivlen || 16;
+        const derivation = this.crypto.pbkdf2Sync(secret, Buffer.from(salt, 'base64'), iterations, keylen + ivlen, 'sha256');
+        const key = derivation.subarray(0, keylen);
+        const iv = derivation.subarray(keylen);
+        const cipher = this.crypto.createDecipheriv('aes-256-cbc', key, iv);
+        let decrypted = cipher.update(encryptedString, 'base64', 'utf8');
+        decrypted += cipher.final('utf8');
+        return decrypted;
+    }
+}

package/lib/esm/impl/cipher/SubtleCryptoCipherUtils.js

@@ -0,0 +1,38 @@
+export class SubtleCryptoCipherUtils {
+    base64Utils;
+    subtleCrypto;
+    constructor(base64Utils, subtleCrypto = crypto.subtle) {
+        this.subtleCrypto = subtleCrypto;
+        this.base64Utils = base64Utils;
+    }
+    async pbkdf2Decrypt(secret, encryptedString, iterations, salt, options) {
+        const ivlen = options?.ivlen || 16;
+        const keylen = options?.keylen || 32;
+        const bitsLength = (ivlen + keylen) * 8;
+        const encodedPassword = new TextEncoder().encode(secret);
+        const encodedSalt = this.base64ToArrayBuffer(salt);
+        const importedKey = await this.subtleCrypto.importKey('raw', encodedPassword, 'PBKDF2', false, ['deriveBits']);
+        const params = { name: 'PBKDF2', hash: 'SHA-256', salt: encodedSalt, iterations: iterations };
+        const derivation = await this.subtleCrypto.deriveBits(params, importedKey, bitsLength);
+        const derivedKey = derivation.slice(0, keylen);
+        const iv = derivation.slice(keylen);
+        const cookieBuffer = this.base64ToArrayBuffer(encryptedString);
+        const importedDecryptionKey = await this.subtleCrypto.importKey('raw', derivedKey, { name: 'AES-CBC' }, false, [
+            'decrypt',
+        ]);
+        const decrypted = await this.subtleCrypto.decrypt({
+            name: 'AES-CBC',
+            iv: iv,
+        }, importedDecryptionKey, cookieBuffer);
+        return new TextDecoder('utf-8').decode(decrypted);
+    }
+    base64ToArrayBuffer(base64String) {
+        const binaryString = this.base64Utils.base64Decode(base64String);
+        const length = binaryString.length;
+        const bytes = new Uint8Array(length);
+        binaryString.split('').forEach((char, index) => {
+            bytes[index] = char.charCodeAt(0);
+        });
+        return bytes.buffer;
+    }
+}

package/lib/esm/impl/hash/CryptoHashUtils.js

@@ -0,0 +1,10 @@
+import * as crypto from 'crypto';
+export class CryptoHashUtils {
+    crypto;
+    constructor(cryptoModule = crypto) {
+        this.crypto = cryptoModule;
+    }
+    async hashString(text, algo) {
+        return this.crypto.createHash(algo).update(text).digest('hex');
+    }
+}

package/lib/esm/impl/hash/CryptoJSHashUtils.js

@@ -0,0 +1,12 @@
+import cryptoJs from 'crypto-js';
+import { Algorithm } from '../../utils';
+export class CryptoJSHashUtils {
+    hashString(text, algo) {
+        switch (algo) {
+            case Algorithm.SHA256:
+                return cryptoJs.SHA256(text).toString(cryptoJs.enc.Hex);
+            default:
+                return null;
+        }
+    }
+}

package/lib/esm/impl/hash/SubtleCryptoHashUtils.js

@@ -0,0 +1,21 @@
+import * as crypto from 'crypto';
+import { Algorithm } from '../../utils';
+export class SubtleCryptoHashUtils {
+    subtle;
+    constructor(subtleCrypto = crypto.subtle) {
+        this.subtle = subtleCrypto;
+    }
+    async hashString(text, algo) {
+        const textUint8 = new TextEncoder().encode(text);
+        const hashBuffer = await this.subtle.digest(this.convertAlgo(algo), textUint8);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
+    }
+    convertAlgo(algo) {
+        switch (algo) {
+            case Algorithm.SHA256:
+            default:
+                return 'SHA-256';
+        }
+    }
+}

package/lib/esm/impl/hmac/CryptoHmacUtils.js

@@ -0,0 +1,20 @@
+import * as crypto from 'crypto';
+import { Algorithm } from '../../utils';
+export class CryptoHmacUtils {
+    crypto;
+    constructor(cryptoModule = crypto) {
+        this.crypto = cryptoModule;
+    }
+    createHmac(algo, payload, secret) {
+        switch (algo) {
+            case Algorithm.SHA256:
+                const hmac = this.crypto.createHmac('sha256', secret);
+                hmac.setEncoding('hex');
+                hmac.write(payload);
+                hmac.end();
+                return hmac.read();
+            default:
+                return '';
+        }
+    }
+}

package/lib/esm/impl/hmac/CryptoJSHmacUtils.js

@@ -0,0 +1,12 @@
+import cryptoJs from 'crypto-js';
+import { Algorithm } from '../../utils';
+export class CryptoJSHmacUtils {
+    createHmac(algo, payload, secret) {
+        switch (algo) {
+            case Algorithm.SHA256:
+                return cryptoJs.HmacSHA256(payload, secret).toString(cryptoJs.enc.Hex);
+            default:
+                return '';
+        }
+    }
+}

package/lib/esm/impl/http/phin/PhinHttpClient.js

@@ -0,0 +1,31 @@
+import { Agent as HttpAgent } from 'http';
+import { Agent as HttpsAgent } from 'https';
+import phin from 'phin';
+import { EnforcerTimeoutError } from '../../../utils';
+import { joinHeaderValues, } from '../../../http/interfaces';
+import { PhinIncomingResponse } from './PhinIncomingResponse';
+export class PhinHttpClient {
+    httpsKeepAliveAgent;
+    constructor() {
+        this.httpsKeepAliveAgent = new HttpsAgent({ keepAlive: true });
+    }
+    async send(request, options) {
+        try {
+            const res = await phin.promisified({
+                url: request.url,
+                method: request.method,
+                headers: joinHeaderValues(request.headers),
+                data: request.body,
+                timeout: options?.timeoutMs || null,
+                core: {
+                    agent: request.url.startsWith('https://') ? this.httpsKeepAliveAgent : new HttpAgent(),
+                },
+            });
+            return new PhinIncomingResponse(res);
+        }
+        catch (e) {
+            const isTimeout = e.toString().toLowerCase().includes('timeout');
+            throw isTimeout ? new EnforcerTimeoutError(options.timeoutMs) : e;
+        }
+    }
+}

package/lib/esm/impl/http/phin/PhinIncomingResponse.js

@@ -0,0 +1,23 @@
+import { CONTENT_TYPE_HEADER_NAME, MultipartFormDataUtils, URLUtils, } from '../../../http';
+export class PhinIncomingResponse {
+    status;
+    headers;
+    body;
+    constructor(response) {
+        this.status = response.statusCode;
+        this.body = response.body;
+        this.headers = Object.fromEntries(Object.entries(response.headers).map(([key, val]) => [key, typeof val === 'string' ? [val] : val]));
+    }
+    async formData() {
+        return MultipartFormDataUtils.createFormDataWithoutFiles(await this.text(), this.headers[CONTENT_TYPE_HEADER_NAME]?.[0]);
+    }
+    async formUrlEncoded() {
+        return URLUtils.parseSearchParams(await this.text());
+    }
+    async json() {
+        return JSON.parse(await this.text());
+    }
+    async text() {
+        return this.body.toString();
+    }
+}

package/lib/esm/impl/url_parser/DefaultUrlParser.js

@@ -0,0 +1,28 @@
+import { URLUtils } from '../../http';
+export class DefaultUrlParser {
+    options;
+    constructor(options) {
+        this.options = {
+            normalize: true,
+            reverseCharactersEncoding: false,
+            ...options,
+        };
+    }
+    parse(rawUrl) {
+        const url = URLUtils.parseURL(rawUrl);
+        if (this.options.reverseCharactersEncoding) {
+            url.pathname = this.reverseCharactersEncoding(url.pathname);
+        }
+        if (this.options.normalize) {
+            url.pathname = this.normalize(url.pathname);
+        }
+        return url;
+    }
+    reverseCharactersEncoding(path) {
+        // NOTICE: Find a suitable polyfill in case decodeURI doesn't exist in the global scope
+        return decodeURI(path);
+    }
+    normalize(path) {
+        return path.replace(/\/+$/, '').replace(/\/+/g, '/');
+    }
+}

package/lib/esm/logger/HttpLogServiceClient.js

@@ -0,0 +1,52 @@
+import { EXTERNAL_LOGGER_SERVICE_PATH } from './constants';
+import { AUTHORIZATION_HEADER_NAME, CONTENT_TYPE_HEADER_NAME, ContentType, HttpMethod, OutgoingRequestImpl, URLUtils, } from '../http';
+import { getAuthorizationHeader } from '../utils';
+export class HttpLogServiceClient {
+    appId;
+    backendUrl;
+    loggerAuthToken;
+    logger;
+    httpClient;
+    constructor(config, httpClient) {
+        this.appId = config.appId;
+        this.backendUrl = config.backendScoreApiUrl;
+        this.loggerAuthToken = config.loggerAuthToken;
+        this.logger = config.logger;
+        this.httpClient = httpClient;
+    }
+    async sendLogs(context, logs) {
+        try {
+            const enrichedLogs = logs.map((log) => this.enrichLogRecord(context, log));
+            await this.postLogs(enrichedLogs);
+        }
+        catch (e) {
+            this.logger.error(`unable to send logs: ${e}`);
+        }
+    }
+    enrichLogRecord(context, log) {
+        const requestData = context.requestData;
+        const url = URLUtils.parseURL(requestData.rawUrl);
+        const logMeta = {
+            container: 'enforcer',
+            appID: this.appId,
+            method: requestData.method,
+            host: url.host,
+            url: requestData.rawUrl,
+            path: url.pathname + requestData.url.search,
+            requestId: context.requestId,
+        };
+        return { ...logMeta, ...log };
+    }
+    async postLogs(logRecords) {
+        const url = `${this.backendUrl}${EXTERNAL_LOGGER_SERVICE_PATH}`;
+        const method = HttpMethod.POST;
+        const headers = {
+            [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
+            [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.loggerAuthToken)],
+        };
+        const body = JSON.stringify(logRecords);
+        const req = new OutgoingRequestImpl({ url, method, headers, body });
+        const res = await this.httpClient.send(req);
+        return res?.status === 200;
+    }
+}

package/lib/esm/logger/LoggerBase.js

@@ -0,0 +1,43 @@
+import { LoggerSeverity } from './LoggerSeverity';
+export class LoggerBase {
+    loggerSeverity;
+    logs;
+    constructor(loggerSeverity = LoggerSeverity.ERROR, logs = []) {
+        this.loggerSeverity = loggerSeverity;
+        this.logs = logs;
+    }
+    debug(message) {
+        this.recordLog(message, LoggerSeverity.DEBUG);
+        if (this.loggerSeverity == LoggerSeverity.DEBUG) {
+            this.logDebug(message);
+        }
+    }
+    error(message) {
+        this.recordLog(message, LoggerSeverity.ERROR);
+        if (this.loggerSeverity != LoggerSeverity.NONE) {
+            this.logError(message);
+        }
+    }
+    getLoggerSeverity() {
+        return this.loggerSeverity;
+    }
+    setLoggerSeverity(loggerSeverity) {
+        this.loggerSeverity = loggerSeverity;
+    }
+    // default implementation, can be overridden
+    logError(message) {
+        this.log(message);
+    }
+    // default implementation, can be overridden
+    logDebug(message) {
+        this.log(message);
+    }
+    // default implementation, can be overridden
+    getLogs() {
+        return this.logs;
+    }
+    recordLog(message, loggerSeverity) {
+        const logRecord = { message: message, severity: loggerSeverity, messageTimestamp: Date.now() };
+        this.logs.push(logRecord);
+    }
+}

package/lib/esm/phase/impl/AdditionalActivityHandlerPhase.js

@@ -0,0 +1,11 @@
+import { AdditionalActivityHandlerUtils } from '../../additional_activity_handler';
+export class AdditionalActivityHandlerPhase {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async execute(context) {
+        await AdditionalActivityHandlerUtils.invokeAdditionalActivityHandler(this.config, context);
+        return { done: false };
+    }
+}

package/lib/esm/phase/impl/CompositePhase.js

@@ -0,0 +1,16 @@
+export class CompositePhase {
+    phases;
+    constructor(phases) {
+        this.phases = phases;
+    }
+    async execute(context) {
+        let result;
+        for (const phase of this.phases) {
+            result = await phase.execute(context);
+            if (result.done) {
+                break;
+            }
+        }
+        return result;
+    }
+}

package/lib/esm/phase/impl/CreateBlockResponsePhase.js

@@ -0,0 +1,50 @@
+import { MinimalResponseUtils } from '../../http';
+import { PXHDSource, PXHDUtils } from '../../pxhd';
+import { Action } from '../../action';
+import { PRODUCT_PRIORITY_ORDER } from '../../products';
+export class CreateBlockResponsePhase {
+    config;
+    blockers;
+    cors;
+    constructor(config, blockers, cors) {
+        this.config = config;
+        this.blockers = blockers;
+        this.cors = cors;
+    }
+    async execute(context) {
+        if (context.action !== Action.BLOCK) {
+            return { done: false };
+        }
+        this.config.logger.debug('create block response phase');
+        let response = this.createBlockResponse(context);
+        if (!response) {
+            return { done: false };
+        }
+        response = await this.addHeadersToResponse(response, context);
+        return { done: true, response };
+    }
+    createBlockResponse(context) {
+        let response = null;
+        for (const name of PRODUCT_PRIORITY_ORDER) {
+            if (context.reasons[name]) {
+                const blocker = this.blockers[name];
+                if (blocker?.shouldBlock(context)) {
+                    this.config.logger.debug(`returning ${name} block response`);
+                    response = blocker.createBlockResponse(context);
+                    break;
+                }
+            }
+        }
+        return response;
+    }
+    async addHeadersToResponse(response, context) {
+        if (!context.isMobile && context.pxhd?.source === PXHDSource.RISK) {
+            response = PXHDUtils.addPxhdToMinimalResponse(context, response);
+        }
+        if (this.config.corsSupportEnabled && this.cors?.isCorsRequest(context)) {
+            const corsHeaders = await this.cors.getCorsBlockHeaders(context);
+            response = MinimalResponseUtils.appendHeaders(response, corsHeaders);
+        }
+        return response;
+    }
+}