perimeterx-js-core 0.1.0

package/lib/risk_api/risk_response_handler/RiskResponseHandlerBase.js

@@ -0,0 +1,73 @@
+"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.RiskResponseHandlerBase = void 0;
+var block_handler_1 = require("../../block_handler");
+var utils_1 = require("../../utils");
+var RiskResponseHandlerBase = /** @class */ (function () {
+    function RiskResponseHandlerBase(config) {
+        this.config = config;
+    }
+    RiskResponseHandlerBase.prototype.handleRiskResponse = function (context, response, riskResponse) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!this.isRiskResponseValid(riskResponse)) {
+                    throw new utils_1.EnforcerException('invalid risk response');
+                }
+                this.config.logger.debug("received risk response, rtt: ".concat(context.riskApiData.riskRtt));
+                this.handleValidRiskResponse(context, riskResponse);
+                return [2 /*return*/];
+            });
+        });
+    };
+    RiskResponseHandlerBase.prototype.handleValidRiskResponse = function (context, riskResponse) {
+        var score = this.extractScoreFromRiskResponse(riskResponse);
+        this.setRiskResponseContextFields(context, riskResponse);
+        if (this.shouldBlock(score)) {
+            context.blockReason = block_handler_1.BlockReason.S2S_HIGH_SCORE;
+        }
+        else {
+            context.passReason = utils_1.PassReason.S2S;
+        }
+    };
+    RiskResponseHandlerBase.prototype.shouldBlock = function (score) {
+        return score >= this.config.blockingScore;
+    };
+    return RiskResponseHandlerBase;
+}());
+exports.RiskResponseHandlerBase = RiskResponseHandlerBase;

package/lib/risk_api/risk_response_handler/RiskResponseV2Handler.d.ts

@@ -0,0 +1,10 @@
+import { IConfiguration } from '../../config';
+import { IContext } from '../../context';
+import { RiskResponseHandlerBase } from './RiskResponseHandlerBase';
+import { RiskResponseV2 } from '../model/RiskResponseV2';
+export declare class RiskResponseV2Handler extends RiskResponseHandlerBase<RiskResponseV2> {
+    constructor(config: IConfiguration);
+    protected isRiskResponseValid(riskResponse: RiskResponseV2): boolean;
+    protected extractScoreFromRiskResponse(riskResponse: RiskResponseV2): number;
+    protected setRiskResponseContextFields(context: IContext, riskResponse: RiskResponseV2): void;
+}

package/lib/risk_api/risk_response_handler/RiskResponseV2Handler.js

@@ -0,0 +1,46 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RiskResponseV2Handler = void 0;
+var utils_1 = require("../../utils");
+var RiskStatus_1 = require("../model/RiskStatus");
+var RiskResponseHandlerBase_1 = require("./RiskResponseHandlerBase");
+var RiskResponseV2Handler = /** @class */ (function (_super) {
+    __extends(RiskResponseV2Handler, _super);
+    function RiskResponseV2Handler(config) {
+        return _super.call(this, config) || this;
+    }
+    RiskResponseV2Handler.prototype.isRiskResponseValid = function (riskResponse) {
+        return (riskResponse === null || riskResponse === void 0 ? void 0 : riskResponse.status) === RiskStatus_1.RiskStatus.SUCCESS && !!(riskResponse === null || riskResponse === void 0 ? void 0 : riskResponse.cookie_cfg_block_result);
+    };
+    RiskResponseV2Handler.prototype.extractScoreFromRiskResponse = function (riskResponse) {
+        return riskResponse.cookie_cfg_block_result === '1' ? 100 : 0;
+    };
+    RiskResponseV2Handler.prototype.setRiskResponseContextFields = function (context, riskResponse) {
+        context.score = this.extractScoreFromRiskResponse(riskResponse);
+        (0, utils_1.transferExistingProperties)(riskResponse, context, {
+            uuid: 'uuid',
+            pxhd: 'pxhd',
+            data_enrichment: 'pxde',
+        });
+        if (riskResponse.data_enrichment) {
+            context.pxdeVerified = true;
+        }
+    };
+    return RiskResponseV2Handler;
+}(RiskResponseHandlerBase_1.RiskResponseHandlerBase));
+exports.RiskResponseV2Handler = RiskResponseV2Handler;

package/lib/risk_api/risk_response_handler/RiskResponseV3Handler.d.ts

@@ -0,0 +1,10 @@
+import { IConfiguration } from '../../config';
+import { IContext } from '../../context';
+import { RiskResponseHandlerBase } from './RiskResponseHandlerBase';
+import { RiskResponseV3 } from '../model/RiskResponseV3';
+export declare class RiskResponseV3Handler extends RiskResponseHandlerBase<RiskResponseV3> {
+    constructor(config: IConfiguration);
+    protected isRiskResponseValid(riskResponse: RiskResponseV3): boolean;
+    protected extractScoreFromRiskResponse(riskResponse: RiskResponseV3): number;
+    protected setRiskResponseContextFields(context: IContext, riskResponse: RiskResponseV3): void;
+}

package/lib/risk_api/risk_response_handler/RiskResponseV3Handler.js

@@ -0,0 +1,47 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RiskResponseV3Handler = void 0;
+var utils_1 = require("../../utils");
+var RiskStatus_1 = require("../model/RiskStatus");
+var RiskResponseHandlerBase_1 = require("./RiskResponseHandlerBase");
+var RiskResponseV3Handler = /** @class */ (function (_super) {
+    __extends(RiskResponseV3Handler, _super);
+    function RiskResponseV3Handler(config) {
+        return _super.call(this, config) || this;
+    }
+    RiskResponseV3Handler.prototype.isRiskResponseValid = function (riskResponse) {
+        return (riskResponse === null || riskResponse === void 0 ? void 0 : riskResponse.status) === RiskStatus_1.RiskStatus.SUCCESS && typeof (riskResponse === null || riskResponse === void 0 ? void 0 : riskResponse.score) === 'number';
+    };
+    RiskResponseV3Handler.prototype.extractScoreFromRiskResponse = function (riskResponse) {
+        return riskResponse.score;
+    };
+    RiskResponseV3Handler.prototype.setRiskResponseContextFields = function (context, riskResponse) {
+        (0, utils_1.transferExistingProperties)(riskResponse, context, {
+            score: 'score',
+            uuid: 'uuid',
+            action: 'blockAction',
+            pxhd: 'pxhd',
+            data_enrichment: 'pxde',
+        });
+        if (riskResponse.data_enrichment) {
+            context.pxdeVerified = true;
+        }
+    };
+    return RiskResponseV3Handler;
+}(RiskResponseHandlerBase_1.RiskResponseHandlerBase));
+exports.RiskResponseV3Handler = RiskResponseV3Handler;

package/lib/risk_token/MobileError.d.ts

@@ -0,0 +1,6 @@
+export declare enum MobileError {
+    NO_COOKIE = "1",
+    CONNECTION_ERROR = "2",
+    CERTIFICATE_PINNING_ERROR = "3",
+    BYPASS = "4"
+}

package/lib/risk_token/MobileError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileError = void 0;
+var MobileError;
+(function (MobileError) {
+    MobileError["NO_COOKIE"] = "1";
+    MobileError["CONNECTION_ERROR"] = "2";
+    MobileError["CERTIFICATE_PINNING_ERROR"] = "3";
+    MobileError["BYPASS"] = "4";
+})(MobileError = exports.MobileError || (exports.MobileError = {}));

package/lib/risk_token/MobileErrorHandler.d.ts

@@ -0,0 +1,9 @@
+import { IConfiguration } from '../config';
+import { IContext } from '../context';
+export declare class MobileErrorHandler {
+    private readonly config;
+    constructor(config: IConfiguration);
+    handleMobileError(context: IContext): Promise<void>;
+    private getS2SCallReasonFromMobileError;
+    private handleFailure;
+}

package/lib/risk_token/MobileErrorHandler.js

@@ -0,0 +1,100 @@
+"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.MobileErrorHandler = void 0;
+var risk_api_1 = require("../risk_api");
+var MobileError_1 = require("./MobileError");
+var TokenVerificationResult_1 = require("./TokenVerificationResult");
+var MobileErrorHandler = /** @class */ (function () {
+    function MobileErrorHandler(config) {
+        this.config = config;
+    }
+    MobileErrorHandler.prototype.handleMobileError = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, originalToken, mobileError, result, e_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 3, , 4]);
+                        _a = context.mobileData, originalToken = _a.originalToken, mobileError = _a.mobileError;
+                        context.riskApiData.s2sCallReason = this.getS2SCallReasonFromMobileError(mobileError);
+                        if (!originalToken) return [3 /*break*/, 2];
+                        return [4 /*yield*/, originalToken.verify(context)];
+                    case 1:
+                        result = _b.sent();
+                        if (result === TokenVerificationResult_1.TokenVerificationResult.DECRYPTION_FAILED) {
+                            return [2 /*return*/, this.handleFailure(context, risk_api_1.S2SCallReason.COOKIE_DECRYPTION_FAILED)];
+                        }
+                        context.mobileData.decodedOriginalToken = originalToken.getPayloadString();
+                        context.uuid = originalToken.uuid;
+                        context.vid = originalToken.vid;
+                        if (result === TokenVerificationResult_1.TokenVerificationResult.VALIDATION_FAILED) {
+                            return [2 /*return*/, this.handleFailure(context, risk_api_1.S2SCallReason.COOKIE_VALIDATION_FAILED)];
+                        }
+                        _b.label = 2;
+                    case 2: return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _b.sent();
+                        this.config.logger.debug("caught exception in mobile error handler - ".concat(e_1));
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MobileErrorHandler.prototype.getS2SCallReasonFromMobileError = function (mobileError) {
+        switch (mobileError) {
+            case MobileError_1.MobileError.NO_COOKIE:
+                return risk_api_1.S2SCallReason.MOBILE_ERROR_NO_COOKIE;
+            case MobileError_1.MobileError.CONNECTION_ERROR:
+                return risk_api_1.S2SCallReason.MOBILE_ERROR_CONNECTION_ERROR;
+            case MobileError_1.MobileError.CERTIFICATE_PINNING_ERROR:
+                return risk_api_1.S2SCallReason.MOBILE_ERROR_CERTIFICATE_PINNING_ERROR;
+            case MobileError_1.MobileError.BYPASS:
+                return risk_api_1.S2SCallReason.MOBILE_ERROR_BYPASS;
+            default:
+                return "mobile_error_".concat(mobileError);
+        }
+    };
+    MobileErrorHandler.prototype.handleFailure = function (context, s2sCallReason) {
+        this.config.logger.debug("could not retrieve original token info - ".concat(s2sCallReason));
+        context.mobileData.originalTokenError = s2sCallReason;
+    };
+    return MobileErrorHandler;
+}());
+exports.MobileErrorHandler = MobileErrorHandler;

package/lib/risk_token/RiskTokenScoreRetriever.d.ts

@@ -0,0 +1,14 @@
+import { IConfiguration } from '../config';
+import { IContext } from '../context';
+import { IScoreRetriever } from '../utils';
+export declare class RiskTokenScoreRetriever implements IScoreRetriever {
+    private readonly config;
+    private readonly mobileErrorHandler;
+    constructor(config: IConfiguration);
+    shouldRetrieveScore(context: IContext): boolean;
+    retrieveScore(context: IContext): Promise<boolean>;
+    private verifyToken;
+    private handleMobileErrorIfNeeded;
+    private handleFailure;
+    private acceptToken;
+}

package/lib/risk_token/RiskTokenScoreRetriever.js

@@ -0,0 +1,148 @@
+"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.RiskTokenScoreRetriever = void 0;
+var utils_1 = require("../utils");
+var risk_api_1 = require("../risk_api");
+var block_handler_1 = require("../block_handler");
+var MobileErrorHandler_1 = require("./MobileErrorHandler");
+var TokenVerificationResult_1 = require("./TokenVerificationResult");
+var RiskTokenScoreRetriever = /** @class */ (function () {
+    function RiskTokenScoreRetriever(config) {
+        this.config = config;
+        this.mobileErrorHandler = new MobileErrorHandler_1.MobileErrorHandler(config);
+    }
+    RiskTokenScoreRetriever.prototype.shouldRetrieveScore = function (context) {
+        return !!context.riskToken || !!context.mobileData.mobileError;
+    };
+    RiskTokenScoreRetriever.prototype.retrieveScore = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var token, e_1, s2sCallReason;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        token = context.riskToken;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 5, , 6]);
+                        if (!!token) return [3 /*break*/, 3];
+                        this.handleFailure(context, risk_api_1.S2SCallReason.NO_COOKIE);
+                        return [4 /*yield*/, this.handleMobileErrorIfNeeded(context)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, false];
+                    case 3: return [4 /*yield*/, this.verifyToken(token, context)];
+                    case 4:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/, false];
+                        }
+                        if (token.isHighScore()) {
+                            context.blockReason = block_handler_1.BlockReason.COOKIE_HIGH_SCORE;
+                        }
+                        else {
+                            context.passReason = utils_1.PassReason.COOKIE;
+                        }
+                        this.config.logger.debug("".concat(token.isHighScore() ? 'high' : 'low', " score cookie found"));
+                        return [2 /*return*/, true];
+                    case 5:
+                        e_1 = _a.sent();
+                        this.config.logger.debug("caught exception in cookie score service - ".concat(e_1));
+                        s2sCallReason = token ? risk_api_1.S2SCallReason.COOKIE_DECRYPTION_FAILED : risk_api_1.S2SCallReason.NO_COOKIE;
+                        return [2 /*return*/, this.handleFailure(context, s2sCallReason)];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    RiskTokenScoreRetriever.prototype.verifyToken = function (token, context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, token.verify(context)];
+                    case 1:
+                        result = _a.sent();
+                        if (result === TokenVerificationResult_1.TokenVerificationResult.DECRYPTION_FAILED) {
+                            return [2 /*return*/, this.handleFailure(context, risk_api_1.S2SCallReason.COOKIE_DECRYPTION_FAILED)];
+                        }
+                        if (result === TokenVerificationResult_1.TokenVerificationResult.VALIDATION_FAILED) {
+                            return [2 /*return*/, this.handleFailure(context, risk_api_1.S2SCallReason.COOKIE_VALIDATION_FAILED)];
+                        }
+                        this.acceptToken(context, token);
+                        if (token.isExpired()) {
+                            return [2 /*return*/, this.handleFailure(context, risk_api_1.S2SCallReason.COOKIE_EXPIRED)];
+                        }
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    RiskTokenScoreRetriever.prototype.handleMobileErrorIfNeeded = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!context.mobileData.mobileError) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.mobileErrorHandler.handleMobileError(context)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    RiskTokenScoreRetriever.prototype.handleFailure = function (context, s2sCallReason) {
+        this.config.logger.debug("could not retrieve cookie score - ".concat(s2sCallReason));
+        context.riskApiData.s2sCallReason = s2sCallReason;
+        return false;
+    };
+    RiskTokenScoreRetriever.prototype.acceptToken = function (context, token) {
+        (0, utils_1.transferExistingProperties)(token, context, {
+            vid: 'vid',
+            uuid: 'uuid',
+            action: 'blockAction',
+            score: 'score',
+        });
+        if (token.vid) {
+            context.vidSource = utils_1.VidSource.RISK_COOKIE;
+        }
+    };
+    return RiskTokenScoreRetriever;
+}());
+exports.RiskTokenScoreRetriever = RiskTokenScoreRetriever;

package/lib/risk_token/TokenOrigin.d.ts

@@ -0,0 +1,4 @@
+export declare enum TokenOrigin {
+    COOKIE = "cookie",
+    HEADER = "header"
+}

package/lib/risk_token/TokenOrigin.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenOrigin = void 0;
+var TokenOrigin;
+(function (TokenOrigin) {
+    TokenOrigin["COOKIE"] = "cookie";
+    TokenOrigin["HEADER"] = "header";
+})(TokenOrigin = exports.TokenOrigin || (exports.TokenOrigin = {}));

package/lib/risk_token/TokenVerificationResult.d.ts

@@ -0,0 +1,6 @@
+export declare enum TokenVerificationResult {
+    CANNOT_VERIFY = -1,
+    SUCCESSFUL = 0,
+    DECRYPTION_FAILED = 1,
+    VALIDATION_FAILED = 2
+}

package/lib/risk_token/TokenVerificationResult.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenVerificationResult = void 0;
+var TokenVerificationResult;
+(function (TokenVerificationResult) {
+    TokenVerificationResult[TokenVerificationResult["CANNOT_VERIFY"] = -1] = "CANNOT_VERIFY";
+    TokenVerificationResult[TokenVerificationResult["SUCCESSFUL"] = 0] = "SUCCESSFUL";
+    TokenVerificationResult[TokenVerificationResult["DECRYPTION_FAILED"] = 1] = "DECRYPTION_FAILED";
+    TokenVerificationResult[TokenVerificationResult["VALIDATION_FAILED"] = 2] = "VALIDATION_FAILED";
+})(TokenVerificationResult = exports.TokenVerificationResult || (exports.TokenVerificationResult = {}));

package/lib/risk_token/TokenVersion.d.ts

@@ -0,0 +1,4 @@
+export declare enum TokenVersion {
+    V2 = "2",
+    V3 = "3"
+}

package/lib/risk_token/TokenVersion.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenVersion = void 0;
+var TokenVersion;
+(function (TokenVersion) {
+    TokenVersion["V2"] = "2";
+    TokenVersion["V3"] = "3";
+})(TokenVersion = exports.TokenVersion || (exports.TokenVersion = {}));

package/lib/risk_token/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const COOKIE_SPLIT_DELIMITER = ":";
+export declare const COOKIE_V2_NAME = "_px2";
+export declare const COOKIE_V3_NAME = "_px3";
+export declare const COOKIE_V3_HMAC_INDEX = 0;
+export declare const COOKIE_V3_SALT_INDEX = 1;
+export declare const COOKIE_V3_ITERATIONS_INDEX = 2;
+export declare const COOKIE_V3_PAYLOAD_INDEX = 3;
+export declare const COOKIE_V3_PARTS_COUNT = 4;
+export declare const COOKIE_V3_MAXIMUM_SALT_LENGTH = 100;

package/lib/risk_token/constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COOKIE_V3_MAXIMUM_SALT_LENGTH = exports.COOKIE_V3_PARTS_COUNT = exports.COOKIE_V3_PAYLOAD_INDEX = exports.COOKIE_V3_ITERATIONS_INDEX = exports.COOKIE_V3_SALT_INDEX = exports.COOKIE_V3_HMAC_INDEX = exports.COOKIE_V3_NAME = exports.COOKIE_V2_NAME = exports.COOKIE_SPLIT_DELIMITER = void 0;
+exports.COOKIE_SPLIT_DELIMITER = ':';
+exports.COOKIE_V2_NAME = '_px2';
+exports.COOKIE_V3_NAME = '_px3';
+exports.COOKIE_V3_HMAC_INDEX = 0;
+exports.COOKIE_V3_SALT_INDEX = 1;
+exports.COOKIE_V3_ITERATIONS_INDEX = 2;
+exports.COOKIE_V3_PAYLOAD_INDEX = 3;
+exports.COOKIE_V3_PARTS_COUNT = 4;
+exports.COOKIE_V3_MAXIMUM_SALT_LENGTH = 100;

package/lib/risk_token/index.d.ts

@@ -0,0 +1,9 @@
+export * from './constants';
+export * from './utils';
+export * from './token';
+export { RiskTokenScoreRetriever } from './RiskTokenScoreRetriever';
+export { MobileErrorHandler } from './MobileErrorHandler';
+export { MobileError } from './MobileError';
+export { TokenOrigin } from './TokenOrigin';
+export { TokenVerificationResult } from './TokenVerificationResult';
+export { TokenVersion } from './TokenVersion';

package/lib/risk_token/index.js

@@ -0,0 +1,32 @@
+"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.TokenVersion = exports.TokenVerificationResult = exports.TokenOrigin = exports.MobileError = exports.MobileErrorHandler = exports.RiskTokenScoreRetriever = void 0;
+__exportStar(require("./constants"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./token"), exports);
+var RiskTokenScoreRetriever_1 = require("./RiskTokenScoreRetriever");
+Object.defineProperty(exports, "RiskTokenScoreRetriever", { enumerable: true, get: function () { return RiskTokenScoreRetriever_1.RiskTokenScoreRetriever; } });
+var MobileErrorHandler_1 = require("./MobileErrorHandler");
+Object.defineProperty(exports, "MobileErrorHandler", { enumerable: true, get: function () { return MobileErrorHandler_1.MobileErrorHandler; } });
+var MobileError_1 = require("./MobileError");
+Object.defineProperty(exports, "MobileError", { enumerable: true, get: function () { return MobileError_1.MobileError; } });
+var TokenOrigin_1 = require("./TokenOrigin");
+Object.defineProperty(exports, "TokenOrigin", { enumerable: true, get: function () { return TokenOrigin_1.TokenOrigin; } });
+var TokenVerificationResult_1 = require("./TokenVerificationResult");
+Object.defineProperty(exports, "TokenVerificationResult", { enumerable: true, get: function () { return TokenVerificationResult_1.TokenVerificationResult; } });
+var TokenVersion_1 = require("./TokenVersion");
+Object.defineProperty(exports, "TokenVersion", { enumerable: true, get: function () { return TokenVersion_1.TokenVersion; } });

package/lib/risk_token/token/BotDefenderTokenBase.d.ts

@@ -0,0 +1,27 @@
+import { IBotDefenderToken } from './IBotDefenderToken';
+import { TokenVerificationResult } from '../TokenVerificationResult';
+import { IContext } from '../../context';
+import { BlockAction } from '../../block_handler';
+import { IConfiguration } from '../../config';
+export declare abstract class BotDefenderTokenBase<PayloadType> implements IBotDefenderToken {
+    abstract readonly action: BlockAction;
+    abstract readonly hmac: string;
+    abstract readonly score: number;
+    abstract readonly timestamp: number;
+    abstract readonly uuid: string;
+    abstract readonly vid: string;
+    abstract isExpired(): boolean;
+    abstract isHighScore(): boolean;
+    protected abstract decrypt(context: IContext): Promise<PayloadType>;
+    protected abstract validate(context: IContext): Promise<boolean>;
+    protected payload: PayloadType;
+    protected cookieString: string;
+    protected cookieSecret: string;
+    protected cookieMaxLength: number;
+    protected isValidated: boolean;
+    protected constructor(config: IConfiguration, cookieString: string);
+    verify(context: IContext): Promise<TokenVerificationResult>;
+    isValid(): boolean;
+    getCookieString(): string;
+    getPayloadString(): string;
+}