perimeterx-js-core 0.2.0 → 0.4.0

package/lib/telemetry/DefaultTelemetry.js

@@ -41,6 +41,8 @@ var http_1 = require("../http");
 var activities_1 = require("../activities");
 var utils_1 = require("../utils");
 var constants_1 = require("./constants");
+var __1 = require("..");
+var __2 = require("..");
 var DefaultTelemetry = /** @class */ (function () {
     function DefaultTelemetry(config, httpClient, base64Utils, hashUtils) {
         this.config = config;
@@ -93,12 +95,11 @@ var DefaultTelemetry = /** @class */ (function () {
         });
     };
     DefaultTelemetry.prototype.getTelemetryHeader = function (context) {
-        var _a;
-        return ((_a = context.requestData.headers.get(constants_1.TELEMETRY_HEADER_NAME)) === null || _a === void 0 ? void 0 : _a[0]) || '';
+        return context.requestData.request.headers.get(constants_1.TELEMETRY_HEADER_NAME) || '';
     };
     DefaultTelemetry.prototype.isTelemetryHeaderValid = function (headerValue) {
         return __awaiter(this, void 0, void 0, function () {
-            var decodedValue, splitValue, timestamp, givenHmac, calculatedHmac, curUnixTime, timestampNumber;
+            var decodedValue, splitValue, timestamp, givenHmac, curUnixTime, timestampNumber;
             return __generator(this, function (_a) {
                 this.config.logger.debug('received command to send enforcer telemetry');
                 decodedValue = this.base64Utils.base64Decode(headerValue);
@@ -109,8 +110,7 @@ var DefaultTelemetry = /** @class */ (function () {
                 }
                 timestamp = splitValue[constants_1.TELEMETRY_HEADER_TIMESTAMP_INDEX];
                 givenHmac = splitValue[constants_1.TELEMETRY_HEADER_HMAC_INDEX];
-                calculatedHmac = this.hashUtils.createHmac(utils_1.Algorithm.SHA256, timestamp, this.config.cookieSecret);
-                if (givenHmac !== calculatedHmac) {
+                if (!this.isTelemetryHmacValid(givenHmac, timestamp)) {
                     this.config.logger.debug("".concat(constants_1.TELEMETRY_HEADER_NAME, " hmac validation failed. original hmac: ").concat(givenHmac, ", timestamp: ").concat(timestamp, "."));
                     return [2 /*return*/, false];
                 }
@@ -124,6 +124,15 @@ var DefaultTelemetry = /** @class */ (function () {
             });
         });
     };
+    DefaultTelemetry.prototype.isTelemetryHmacValid = function (givenHmac, timestamp) {
+        try {
+            return givenHmac === this.hashUtils.createHmac(utils_1.Algorithm.SHA256, timestamp, this.config.cookieSecret);
+        }
+        catch (e) {
+            this.config.logger.debug("caught error validating telemetry hmac: ".concat(e));
+            return false;
+        }
+    };
     DefaultTelemetry.prototype.sendTelemetryActivity = function (context) {
         return __awaiter(this, void 0, void 0, function () {
             var telemetryRequest;
@@ -143,13 +152,13 @@ var DefaultTelemetry = /** @class */ (function () {
     DefaultTelemetry.prototype.createTelemetryRequest = function (context) {
         var _a;
         var url = "".concat(this.config.backendScoreApiUrl).concat(constants_1.TELEMETRY_ENDPOINT);
-        var method = http_1.HttpMethod.POST;
+        var method = __1.HttpMethod.POST;
         var headers = (_a = {},
             _a[http_1.CONTENT_TYPE_HEADER_NAME] = [http_1.ContentType.APPLICATION_JSON],
             _a[http_1.AUTHORIZATION_HEADER_NAME] = [(0, utils_1.getAuthorizationHeader)(this.config.authToken)],
             _a);
         var activity = this.createTelemetryActivity(context);
-        return new http_1.DefaultHttpRequest(url, { method: method, headers: headers, body: JSON.stringify(activity) });
+        return new __2.OutgoingRequestImpl({ url: url, method: method, headers: headers, body: JSON.stringify(activity) });
     };
     DefaultTelemetry.prototype.createTelemetryActivity = function (context) {
         var SENSITIVE_CONFIG_FIELDS = ['px_auth_token', 'px_cookie_secret'];

package/lib/utils/IScoreRetriever.d.ts

@@ -1,4 +1,4 @@
-import { IContext } from '../context/IContext';
+import { IContext } from '../context';
 export interface IScoreRetriever {
     /**
      * @param context - The request context.

package/lib/utils/base64/{DefaultBase64Utils.d.ts → AtobBase64Utils.d.ts}

@@ -1,5 +1,5 @@
 import { IBase64Utils } from './IBase64Utils';
-export declare class DefaultBase64Utils implements IBase64Utils {
-    base64Encode(stringToEncode: string): string;
+export declare class AtobBase64Utils implements IBase64Utils {
     base64Decode(stringToDecode: string): string;
+    base64Encode(stringToEncode: string): string;
 }

package/lib/utils/base64/AtobBase64Utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtobBase64Utils = void 0;
+var AtobBase64Utils = /** @class */ (function () {
+    function AtobBase64Utils() {
+    }
+    AtobBase64Utils.prototype.base64Decode = function (stringToDecode) {
+        return atob(stringToDecode);
+    };
+    AtobBase64Utils.prototype.base64Encode = function (stringToEncode) {
+        return btoa(stringToEncode);
+    };
+    return AtobBase64Utils;
+}());
+exports.AtobBase64Utils = AtobBase64Utils;

package/lib/utils/base64/BufferBase64Utils.d.ts

@@ -0,0 +1,6 @@
+import { IBase64Utils } from './IBase64Utils';
+export declare class BufferBase64Utils implements IBase64Utils {
+    static BASE_64_ENCODING: 'base64';
+    base64Decode(stringToDecode: string): string;
+    base64Encode(stringToEncode: string): string;
+}

package/lib/utils/base64/BufferBase64Utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferBase64Utils = void 0;
+var BufferBase64Utils = /** @class */ (function () {
+    function BufferBase64Utils() {
+    }
+    BufferBase64Utils.prototype.base64Decode = function (stringToDecode) {
+        var buffer = Buffer.from(stringToDecode, BufferBase64Utils.BASE_64_ENCODING);
+        return buffer.toString();
+    };
+    BufferBase64Utils.prototype.base64Encode = function (stringToEncode) {
+        var buffer = Buffer.from(stringToEncode);
+        return buffer.toString(BufferBase64Utils.BASE_64_ENCODING);
+    };
+    BufferBase64Utils.BASE_64_ENCODING = 'base64';
+    return BufferBase64Utils;
+}());
+exports.BufferBase64Utils = BufferBase64Utils;

package/lib/utils/base64/JSBase64Base64Utils.d.ts

@@ -0,0 +1,5 @@
+import { IBase64Utils } from './IBase64Utils';
+export declare class JSBase64Base64Utils implements IBase64Utils {
+    base64Encode(stringToEncode: string): string;
+    base64Decode(stringToDecode: string): string;
+}

package/lib/utils/base64/JSBase64Base64Utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSBase64Base64Utils = void 0;
+var js_base64_1 = require("js-base64");
+var JSBase64Base64Utils = /** @class */ (function () {
+    function JSBase64Base64Utils() {
+    }
+    JSBase64Base64Utils.prototype.base64Encode = function (stringToEncode) {
+        return (0, js_base64_1.encode)(stringToEncode);
+    };
+    JSBase64Base64Utils.prototype.base64Decode = function (stringToDecode) {
+        return (0, js_base64_1.decode)(stringToDecode);
+    };
+    return JSBase64Base64Utils;
+}());
+exports.JSBase64Base64Utils = JSBase64Base64Utils;

package/lib/utils/base64/index.d.ts

@@ -1,2 +1,4 @@
-export { IBase64Utils } from './IBase64Utils';
-export { DefaultBase64Utils } from './DefaultBase64Utils';
+export * from './IBase64Utils';
+export * from './JSBase64Base64Utils';
+export * from './BufferBase64Utils';
+export * from './AtobBase64Utils';

package/lib/utils/base64/index.js

@@ -1,5 +1,20 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultBase64Utils = void 0;
-var DefaultBase64Utils_1 = require("./DefaultBase64Utils");
-Object.defineProperty(exports, "DefaultBase64Utils", { enumerable: true, get: function () { return DefaultBase64Utils_1.DefaultBase64Utils; } });
+__exportStar(require("./IBase64Utils"), exports);
+__exportStar(require("./JSBase64Base64Utils"), exports);
+__exportStar(require("./BufferBase64Utils"), exports);
+__exportStar(require("./AtobBase64Utils"), exports);

package/lib/utils/cipher/CryptoCipherUtils.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import * as crypto from 'crypto';
+import { IBase64Utils } from '../base64';
+import { ICipherUtils, Pbkdf2DecryptOptions } from './ICipherUtils';
+declare type CryptoModule = typeof crypto;
+export declare class CryptoCipherUtils implements ICipherUtils {
+    private crypto;
+    private base64Utils;
+    constructor(base64Utils: IBase64Utils, cryptoModule?: CryptoModule);
+    pbkdf2Decrypt(secret: string, encryptedString: string, iterations: number, salt: string, options?: Pbkdf2DecryptOptions): Promise<string>;
+}
+export {};

package/lib/{http/body_reader/StringBodyReader.js → utils/cipher/CryptoCipherUtils.js}

@@ -36,35 +36,30 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringBodyReader = void 0;
-var StringBodyReader = /** @class */ (function () {
-    function StringBodyReader(rawBody) {
-        this.body = rawBody;
+exports.CryptoCipherUtils = void 0;
+var crypto = require("crypto");
+var CryptoCipherUtils = /** @class */ (function () {
+    function CryptoCipherUtils(base64Utils, cryptoModule) {
+        if (cryptoModule === void 0) { cryptoModule = crypto; }
+        this.crypto = cryptoModule;
+        this.base64Utils = base64Utils;
     }
-    StringBodyReader.prototype.readBody = function (contentType) {
+    CryptoCipherUtils.prototype.pbkdf2Decrypt = function (secret, encryptedString, iterations, salt, options) {
         return __awaiter(this, void 0, void 0, function () {
+            var keylen, ivlen, derivation, key, iv, cipher, decrypted;
             return __generator(this, function (_a) {
-                if (!contentType) {
-                    return [2 /*return*/, this.body];
-                }
-                if (contentType.includes('json')) {
-                    return [2 /*return*/, JSON.parse(this.body)];
-                }
-                else if (contentType.includes('form-urlencoded')) {
-                    return [2 /*return*/, this.convertFormUrlEncodedStringToObject(this.body)];
-                }
-                return [2 /*return*/, this.body];
+                keylen = (options === null || options === void 0 ? void 0 : options.keylen) || 32;
+                ivlen = (options === null || options === void 0 ? void 0 : options.ivlen) || 16;
+                derivation = this.crypto.pbkdf2Sync(secret, this.base64Utils.base64Decode(salt), iterations, keylen + ivlen, 'sha256');
+                key = derivation.subarray(0, keylen);
+                iv = derivation.subarray(keylen);
+                cipher = this.crypto.createDecipheriv('aes-256-cbc', key, iv);
+                decrypted = cipher.update(encryptedString, 'base64', 'utf8');
+                decrypted += cipher.final('utf8');
+                return [2 /*return*/, decrypted];
             });
         });
     };
-    StringBodyReader.prototype.convertFormUrlEncodedStringToObject = function (formUrlEncodedString) {
-        var object = {};
-        var params = new URLSearchParams(formUrlEncodedString);
-        params.forEach(function (value, key) {
-            object[key] = value;
-        });
-        return object;
-    };
-    return StringBodyReader;
+    return CryptoCipherUtils;
 }());
-exports.StringBodyReader = StringBodyReader;
+exports.CryptoCipherUtils = CryptoCipherUtils;

package/lib/utils/cipher/SubtleCryptoCipherUtils.d.ts

@@ -0,0 +1,9 @@
+import { IBase64Utils } from '../base64';
+import { ICipherUtils, Pbkdf2DecryptOptions } from './ICipherUtils';
+export declare class SubtleCryptoCipherUtils implements ICipherUtils {
+    private base64Utils;
+    private subtleCrypto;
+    constructor(base64Utils: IBase64Utils, subtleCrypto?: SubtleCrypto);
+    pbkdf2Decrypt(secret: string, encryptedString: string, iterations: number, salt: string, options?: Pbkdf2DecryptOptions): Promise<string>;
+    private base64ToArrayBuffer;
+}

package/lib/utils/cipher/SubtleCryptoCipherUtils.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+var __generator = (this && this.__generator) || function (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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubtleCryptoCipherUtils = void 0;
+var SubtleCryptoCipherUtils = /** @class */ (function () {
+    function SubtleCryptoCipherUtils(base64Utils, subtleCrypto) {
+        if (subtleCrypto === void 0) { subtleCrypto = crypto.subtle; }
+        this.subtleCrypto = subtleCrypto;
+        this.base64Utils = base64Utils;
+    }
+    SubtleCryptoCipherUtils.prototype.pbkdf2Decrypt = function (secret, encryptedString, iterations, salt, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ivlen, keylen, bitsLength, encodedPassword, encodedSalt, importedKey, params, derivation, derivedKey, iv, cookieBuffer, importedDecryptionKey, decrypted;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ivlen = (options === null || options === void 0 ? void 0 : options.ivlen) || 16;
+                        keylen = (options === null || options === void 0 ? void 0 : options.keylen) || 32;
+                        bitsLength = (ivlen + keylen) * 8;
+                        encodedPassword = new TextEncoder().encode(secret);
+                        encodedSalt = this.base64ToArrayBuffer(salt);
+                        return [4 /*yield*/, this.subtleCrypto.importKey('raw', encodedPassword, 'PBKDF2', false, ['deriveBits'])];
+                    case 1:
+                        importedKey = _a.sent();
+                        params = { name: 'PBKDF2', hash: 'SHA-256', salt: encodedSalt, iterations: iterations };
+                        return [4 /*yield*/, this.subtleCrypto.deriveBits(params, importedKey, bitsLength)];
+                    case 2:
+                        derivation = _a.sent();
+                        derivedKey = derivation.slice(0, keylen);
+                        iv = derivation.slice(keylen);
+                        cookieBuffer = this.base64ToArrayBuffer(encryptedString);
+                        return [4 /*yield*/, this.subtleCrypto.importKey('raw', derivedKey, { name: 'AES-CBC' }, false, [
+                                'decrypt',
+                            ])];
+                    case 3:
+                        importedDecryptionKey = _a.sent();
+                        return [4 /*yield*/, this.subtleCrypto.decrypt({
+                                name: 'AES-CBC',
+                                iv: iv,
+                            }, importedDecryptionKey, cookieBuffer)];
+                    case 4:
+                        decrypted = _a.sent();
+                        return [2 /*return*/, new TextDecoder('utf-8').decode(decrypted)];
+                }
+            });
+        });
+    };
+    SubtleCryptoCipherUtils.prototype.base64ToArrayBuffer = function (base64String) {
+        var binaryString = this.base64Utils.base64Decode(base64String);
+        var length = binaryString.length;
+        var bytes = new Uint8Array(length);
+        binaryString.split('').forEach(function (char, index) {
+            bytes[index] = char.charCodeAt(0);
+        });
+        return bytes.buffer;
+    };
+    return SubtleCryptoCipherUtils;
+}());
+exports.SubtleCryptoCipherUtils = SubtleCryptoCipherUtils;

package/lib/utils/cipher/index.d.ts

@@ -1 +1,3 @@
 export { ICipherUtils, Pbkdf2DecryptOptions } from './ICipherUtils';
+export * from './SubtleCryptoCipherUtils';
+export * from './CryptoCipherUtils';

package/lib/utils/cipher/index.js

@@ -1,2 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./SubtleCryptoCipherUtils"), exports);
+__exportStar(require("./CryptoCipherUtils"), exports);

package/lib/utils/constants.d.ts

@@ -7,4 +7,4 @@ export declare const BYPASS_MONITOR_HEADER_VALUE = "1";
 export declare const X_PX_AUTHORIZATION_HEADER_NAME = "x-px-authorization";
 export declare const X_PX_ORIGINAL_TOKEN_HEADER_NAME = "x-px-original-token";
 export declare const X_PX_BYPASS_REASON_HEADER_NAME = "x-px-bypass-reason";
-export declare const CORE_MODULE_VERSION = "JS Core 0.2.0";
+export declare const CORE_MODULE_VERSION = "JS Core 0.4.0";

package/lib/utils/constants.js

@@ -10,4 +10,4 @@ exports.BYPASS_MONITOR_HEADER_VALUE = '1';
 exports.X_PX_AUTHORIZATION_HEADER_NAME = 'x-px-authorization';
 exports.X_PX_ORIGINAL_TOKEN_HEADER_NAME = 'x-px-original-token';
 exports.X_PX_BYPASS_REASON_HEADER_NAME = 'x-px-bypass-reason';
-exports.CORE_MODULE_VERSION = 'JS Core 0.2.0';
+exports.CORE_MODULE_VERSION = 'JS Core 0.4.0';

package/lib/utils/hash/CryptoHmacUtils.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import * as crypto from 'crypto';
+import { IHashUtils } from './IHashUtils';
+import { Algorithm } from '../Algorithm';
+declare type CryptoModule = typeof crypto;
+export declare class CryptoHmacUtils implements IHashUtils {
+    private readonly crypto;
+    constructor(cryptoModule?: CryptoModule);
+    createHmac(algo: Algorithm, payload: string, secret: string): string;
+}
+export {};

package/lib/utils/hash/CryptoHmacUtils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoHmacUtils = void 0;
+var crypto = require("crypto");
+var Algorithm_1 = require("../Algorithm");
+var CryptoHmacUtils = /** @class */ (function () {
+    function CryptoHmacUtils(cryptoModule) {
+        if (cryptoModule === void 0) { cryptoModule = crypto; }
+        this.crypto = cryptoModule;
+    }
+    CryptoHmacUtils.prototype.createHmac = function (algo, payload, secret) {
+        switch (algo) {
+            case Algorithm_1.Algorithm.SHA256:
+                var hmac = this.crypto.createHmac('sha256', secret);
+                hmac.setEncoding('hex');
+                hmac.write(payload);
+                hmac.end();
+                return hmac.read();
+            default:
+                return '';
+        }
+    };
+    return CryptoHmacUtils;
+}());
+exports.CryptoHmacUtils = CryptoHmacUtils;

package/lib/utils/hash/{DefaultHashUtils.d.ts → CryptoJSHmacUtils.d.ts}

@@ -1,5 +1,5 @@
 import { IHashUtils } from './IHashUtils';
 import { Algorithm } from '../Algorithm';
-export declare class DefaultHashUtils implements IHashUtils {
+export declare class CryptoJSHmacUtils implements IHashUtils {
     createHmac(algo: Algorithm, payload: string, secret: string): string;
 }

package/lib/utils/hash/CryptoJSHmacUtils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoJSHmacUtils = void 0;
+var crypto_js_1 = require("crypto-js");
+var Algorithm_1 = require("../Algorithm");
+var CryptoJSHmacUtils = /** @class */ (function () {
+    function CryptoJSHmacUtils() {
+    }
+    CryptoJSHmacUtils.prototype.createHmac = function (algo, payload, secret) {
+        switch (algo) {
+            case Algorithm_1.Algorithm.SHA256:
+                return (0, crypto_js_1.HmacSHA256)(payload, secret).toString(crypto_js_1.enc.Hex);
+            default:
+                return '';
+        }
+    };
+    return CryptoJSHmacUtils;
+}());
+exports.CryptoJSHmacUtils = CryptoJSHmacUtils;

package/lib/utils/hash/index.d.ts

@@ -1,2 +1,3 @@
-export { IHashUtils } from './IHashUtils';
-export { DefaultHashUtils } from './DefaultHashUtils';
+export * from './IHashUtils';
+export * from './CryptoHmacUtils';
+export * from './CryptoJSHmacUtils';

package/lib/utils/hash/index.js

@@ -1,5 +1,19 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultHashUtils = void 0;
-var DefaultHashUtils_1 = require("./DefaultHashUtils");
-Object.defineProperty(exports, "DefaultHashUtils", { enumerable: true, get: function () { return DefaultHashUtils_1.DefaultHashUtils; } });
+__exportStar(require("./IHashUtils"), exports);
+__exportStar(require("./CryptoHmacUtils"), exports);
+__exportStar(require("./CryptoJSHmacUtils"), exports);

package/lib/utils/utils.d.ts

@@ -1,4 +1,3 @@
-import { HttpHeaders } from '../http';
 export declare const isValidEnumValue: <T>(options: Record<string, T>, selection: T) => boolean;
 export declare const isValidUuid: (uuid: string) => boolean;
 export declare const getScoreApiDomain: (appId: string) => string;
@@ -7,7 +6,7 @@ export declare const getAuthorizationHeader: (authToken: string) => string;
 export declare const getExtension: (route: string) => string;
 export declare const getDecodedUrl: (rawUrl: string) => URL;
 export declare const removeSensitiveFields: <T extends Record<string, any>>(object: T, sensitiveFields: (keyof T)[]) => T;
-export declare const removeSensitiveHeaders: (headers: HttpHeaders, sensitiveHeaderNames: string[]) => HttpHeaders;
+export declare const removeSensitiveHeaders: (headers: Record<string, string[]>, sensitiveHeaderNames: string[]) => Record<string, string[]>;
 export declare const isRouteInPatterns: (route: string, patterns: Array<string | RegExp>) => boolean;
 export declare const isRouteMatch: (route: string, pattern: string | RegExp) => boolean;
 export declare const transferExistingProperties: <FromObj extends Record<string, any>, ToObj extends Record<string, any>>(fromObj: FromObj, toObj: ToObj, propertyMappings: Partial<Record<keyof FromObj, keyof ToObj>>) => void;

package/lib/utils/utils.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
 var __awaiter = (this && this.__awaiter) || function (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) {
@@ -89,11 +100,11 @@ var removeSensitiveFields = function (object, sensitiveFields) {
 };
 exports.removeSensitiveFields = removeSensitiveFields;
 var removeSensitiveHeaders = function (headers, sensitiveHeaderNames) {
-    var headersCopy = headers.copy();
+    var ret = __assign({}, headers);
     sensitiveHeaderNames.forEach(function (name) {
-        headersCopy.delete(name);
+        delete ret[name];
     });
-    return headersCopy;
+    return ret;
 };
 exports.removeSensitiveHeaders = removeSensitiveHeaders;
 var isRouteInPatterns = function (route, patterns) {
@@ -104,7 +115,7 @@ var isRouteMatch = function (route, pattern) {
     if (!route || !pattern) {
         return false;
     }
-    if (pattern instanceof RegExp && route.match(pattern)) {
+    if (pattern instanceof RegExp && pattern.test(route)) {
         return true;
     }
     if (typeof pattern === 'string' && route.startsWith(pattern)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perimeterx-js-core",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -39,7 +39,6 @@
     "core-js": "^3.19.1",
     "eslint": "^8.25.0",
     "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-no-loops": "^0.3.0",
     "eslint-plugin-prettier": "^4.2.1",
     "husky": "^8.0.3",
     "lint-staged": "^13.1.0",

package/lib/http/IHttpClient.d.ts

@@ -1,14 +0,0 @@
-import { IHttpRequest } from './request/IHttpRequest';
-import { IHttpResponse } from './response/IHttpResponse';
-export declare type HttpSendOptions = {
-    timeoutMs?: number;
-};
-export interface IHttpClient<UnreadBodyType = unknown> {
-    /**
-     * A function that sends the provided IHttpRequest and returns a Promise resolving to an IHttpResponse.
-     * @param request - The request to be sent by the client.
-     * @param options - Options that the HttpClient should consider
-     * @returns Promise<IHttpResponse> - A Promise resolving to the response the client received.
-     */
-    send(request: IHttpRequest<UnreadBodyType>, options?: HttpSendOptions): Promise<IHttpResponse<UnreadBodyType>>;
-}

package/lib/http/body_reader/IBodyReader.d.ts

@@ -1,5 +0,0 @@
-import { ContentType, HttpBody } from '../utils';
-export interface IBodyReader<UnreadBodyType> {
-    readonly body: UnreadBodyType | string;
-    readBody(contentType: ContentType): Promise<HttpBody>;
-}

package/lib/http/body_reader/StringBodyReader.d.ts

@@ -1,8 +0,0 @@
-import { ContentType, HttpBody } from '../utils';
-import { IBodyReader } from './IBodyReader';
-export declare class StringBodyReader implements IBodyReader<string> {
-    readonly body: string;
-    constructor(rawBody: string);
-    readBody(contentType: ContentType): Promise<HttpBody>;
-    private convertFormUrlEncodedStringToObject;
-}

package/lib/http/request/DefaultHttpRequest.d.ts

@@ -1,5 +0,0 @@
-import { HttpRequestBase, HttpRequestOptions } from './HttpRequestBase';
-export declare class DefaultHttpRequest extends HttpRequestBase<string, DefaultHttpRequest> {
-    constructor(url: string, options?: HttpRequestOptions<string>);
-    getUnderlyingRequest(): DefaultHttpRequest;
-}