@netacea/f5 4.3.122 → 4.3.124

package/dist/src/F5.js

@@ -1,681 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const netaceaintegrationbase_1 = require("@netacea/netaceaintegrationbase");
-const https = require("https");
-const pack = require("../package.json");
-const kinesisingest_1 = require("@netacea/kinesisingest");
-const defaultTimeout = 3000; // 3 seconds?
-const ONE_HOUR_IN_SECONDS = 60 * 60;
-const ONE_DAY_IN_SECONDS = ONE_HOUR_IN_SECONDS * 24;
-class NetaceaBase {
-    constructor({ apiKey, secretKey, timeout = defaultTimeout, mitigationServiceUrl = 'https://mitigations.netacea.net', ingestServiceUrl = 'https://ingest.netacea.net', mitigationType = netaceaintegrationbase_1.NetaceaMitigationType.INGEST, captchaSiteKey, captchaSecretKey, ingestType = netaceaintegrationbase_1.NetaceaIngestType.HTTP, kinesis, mitataCookieExpirySeconds, netaceaCookieExpirySeconds, netaceaCookieName, netaceaCaptchaCookieName }) {
-        this.encryptedCookies = [];
-        if (apiKey === null || apiKey === undefined) {
-            throw new Error('apiKey is a required parameter');
-        }
-        this.apiKey = apiKey;
-        this.secretKey = secretKey;
-        this.mitigationServiceUrl = mitigationServiceUrl;
-        this.ingestServiceUrl = ingestServiceUrl;
-        this.mitigationType = mitigationType;
-        this.ingestType = ingestType !== null && ingestType !== void 0 ? ingestType : netaceaintegrationbase_1.NetaceaIngestType.HTTP;
-        if (this.ingestType === netaceaintegrationbase_1.NetaceaIngestType.KINESIS) {
-            if (kinesis === undefined) {
-                console.warn(`NETACEA WARN: no kinesis args provided, when ingestType is ${this.ingestType}`);
-            }
-            else {
-                this.kinesis = new kinesisingest_1.default({
-                    ...kinesis,
-                    apiKey: this.apiKey
-                });
-            }
-        }
-        if (captchaSiteKey !== undefined || captchaSecretKey !== undefined) {
-            this.captchaSiteKey = captchaSiteKey;
-            this.captchaSecretKey = captchaSecretKey;
-        }
-        this.timeout = (0, netaceaintegrationbase_1.correctTimeout)(timeout);
-        this.netaceaCookieName = netaceaCookieName !== null && netaceaCookieName !== void 0 ? netaceaCookieName : '_mitata';
-        this.netaceaCaptchaCookieName = netaceaCaptchaCookieName !== null && netaceaCaptchaCookieName !== void 0 ? netaceaCaptchaCookieName : '_mitatacaptcha';
-        this.encryptedCookies = [
-            this.netaceaCookieName,
-            this.netaceaCaptchaCookieName
-        ];
-        this.mitataCookieExpirySeconds = (0, netaceaintegrationbase_1.configureMitataExpiry)(mitigationType, netaceaCookieExpirySeconds !== null && netaceaCookieExpirySeconds !== void 0 ? netaceaCookieExpirySeconds : mitataCookieExpirySeconds);
-    }
-    async runMitigation(args) {
-        try {
-            switch (this.mitigationType) {
-                case netaceaintegrationbase_1.NetaceaMitigationType.MITIGATE:
-                    return await this.mitigate(args);
-                case netaceaintegrationbase_1.NetaceaMitigationType.INJECT:
-                    return await this.inject(args);
-                case netaceaintegrationbase_1.NetaceaMitigationType.INGEST:
-                    return await this.processIngest(args);
-                default:
-                    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                    throw new Error(`Netacea Error: Mitigation type ${this.mitigationType} not recognised`);
-            }
-        }
-        catch (e) {
-            console.error('Netacea FAILOPEN Error:', e);
-            const requestArgs = args;
-            const isCaptchaPost = this.isUrlCaptchaPost(requestArgs.url, requestArgs.method);
-            const isMitigate = this.mitigationType === netaceaintegrationbase_1.NetaceaMitigationType.MITIGATE;
-            return {
-                injectHeaders: {
-                    'x-netacea-captcha': '0',
-                    'x-netacea-match': '0',
-                    'x-netacea-mitigate': '0'
-                },
-                sessionStatus: isMitigate && isCaptchaPost ? 'error_open' : ''
-            };
-        }
-    }
-    /**
-     * Returns the value of the cookie with the given name from a string or list of cookies.
-     * If the cookie name is included in the encryptedCookies class property,
-     * then the cookie value will be decrypted automatically.
-     * The method may operate of either the HTTP Cookie or Set-Cookie headers.
-     * @param cookieName the name of the cookie to find.
-     * @param cookies the full list of cookies, either as a string or an array of strings.
-     * @returns the value of the cookie, if found.
-     */
-    async readCookie(cookieName, cookies) {
-        if (cookies === null || cookies === undefined) {
-            return undefined;
-        }
-        if (typeof cookies === 'string') {
-            return await this.readCookie(cookieName, cookies.split(';'));
-        }
-        const valuePrefix = `${cookieName}=`;
-        for (const cookie of cookies) {
-            // split again on ; to handle Set-Cookie header format.
-            const trimmedCookie = cookie.split(';')[0].trimStart();
-            if (trimmedCookie.startsWith(valuePrefix)) {
-                const cookieValue = trimmedCookie.slice(valuePrefix.length);
-                if (this.encryptedCookies.includes(cookieName)) {
-                    try {
-                        return await this.decryptCookieValue(cookieValue);
-                    }
-                    catch (_e) {
-                        return undefined;
-                    }
-                }
-                return cookieValue;
-            }
-        }
-        return undefined;
-    }
-    async callIngest(args) {
-        const body = this.constructWebLog(args);
-        if (this.ingestType === netaceaintegrationbase_1.NetaceaIngestType.KINESIS) {
-            if (this.kinesis === undefined) {
-                console.error('Netacea Error: Unable to log as Kinesis has not been defined.');
-                return;
-            }
-            try {
-                await this.kinesis.ingest({
-                    ...body,
-                    apiKey: this.apiKey
-                }, this.makeRequest.bind(this));
-            }
-            catch (e) {
-                console.error('NETACEA Error: ', e.message);
-            }
-        }
-        else {
-            const headers = {
-                'X-Netacea-API-Key': this.apiKey,
-                'content-type': 'application/json'
-            };
-            const res = await this.makeIngestApiCall(headers, body);
-            if (res.status !== 200) {
-                throw this.APIError(res);
-            }
-        }
-    }
-    async makeIngestApiCall(headers, body) {
-        return await this.makeRequest({
-            host: this.ingestServiceUrl,
-            method: 'POST',
-            path: '/',
-            headers,
-            body: JSON.stringify(body),
-            timeout: this.timeout
-        });
-    }
-    constructV1WebLog({ ip, userAgent, status, method, path, protocol, referer, bytesSent, requestTime, mitataCookie, sessionStatus, integrationType, integrationVersion }) {
-        const timestamp = new Date().toUTCString();
-        return {
-            Request: `${method} ${path} ${protocol}`,
-            TimeLocal: timestamp,
-            RealIp: ip,
-            UserAgent: userAgent,
-            Status: status,
-            RequestTime: requestTime === null || requestTime === void 0 ? void 0 : requestTime.toString(),
-            BytesSent: bytesSent === null || bytesSent === void 0 ? void 0 : bytesSent.toString(),
-            Referer: referer === '' ? '-' : referer,
-            NetaceaUserIdCookie: mitataCookie !== null && mitataCookie !== void 0 ? mitataCookie : '',
-            NetaceaMitigationApplied: sessionStatus !== null && sessionStatus !== void 0 ? sessionStatus : '',
-            IntegrationType: integrationType !== null && integrationType !== void 0 ? integrationType : '',
-            IntegrationVersion: integrationVersion !== null && integrationVersion !== void 0 ? integrationVersion : ''
-        };
-    }
-    constructWebLog(args) {
-        args.bytesSent = args.bytesSent === '' ? '0' : args.bytesSent;
-        return this.constructV1WebLog(args);
-    }
-    async check(netaceaCookie, clientIP, userAgent, captchaCookie) {
-        var _a, _b;
-        let status, match, mitigate, captcha, body, setCookie, eventId;
-        if (this.secretKey === undefined) {
-            throw new Error('Secret key is required to mitigate');
-        }
-        const cookieInfo = (0, netaceaintegrationbase_1.checkMitataCookie)(netaceaCookie, clientIP, this.secretKey);
-        if (!cookieInfo.isPrimaryHashValid || cookieInfo.requiresReissue) {
-            // Get latest mitigation information
-            const result = await this.makeMitigateAPICall((_a = cookieInfo.mitata) === null || _a === void 0 ? void 0 : _a.userId, clientIP, userAgent, captchaCookie);
-            status = result.status;
-            match = result.match;
-            mitigate = result.mitigate;
-            captcha = result.captcha;
-            body = result.body;
-            setCookie = [
-                await this.createMitata(clientIP, (_b = cookieInfo.mitata) === null || _b === void 0 ? void 0 : _b.userId, match, mitigate, captcha, result.mitataMaxAge)
-            ];
-            eventId = result.eventId;
-        }
-        else {
-            status = -1;
-            match = cookieInfo.match;
-            mitigate = cookieInfo.mitigate;
-            captcha = cookieInfo.captcha;
-            body = undefined;
-            setCookie = [];
-        }
-        return this.composeResult(body, setCookie, status, match, mitigate, captcha, false, eventId);
-    }
-    async createMitata(clientIP, userId, match, mitigate, captcha, maxAge = 86400, expiry = undefined) {
-        // serve, fail, cookiefail
-        const isCaptchaServe = ['1', '3', '5'].includes(captcha);
-        const isHardBlocked = mitigate === '3';
-        const expiryDelta = (isCaptchaServe || isHardBlocked)
-            ? -60
-            : this.mitataCookieExpirySeconds;
-        const mitataExpiry = expiry !== null && expiry !== void 0 ? expiry : Math.floor(Date.now() / 1000) + expiryDelta;
-        if (this.secretKey === undefined) {
-            throw new Error('Cannot build cookie without secret key.');
-        }
-        const mitataCode = [match, mitigate, captcha].join('');
-        const mitataValue = (0, netaceaintegrationbase_1.createMitataCookie)(clientIP, userId, mitataExpiry, this.secretKey, mitataCode);
-        return await this.buildCookieFromValues(this.netaceaCookieName, mitataValue, maxAge, '/');
-    }
-    async processCaptcha(netaceaCookie, clientIP, userAgent, captchaData) {
-        const { status, match, mitigate, captcha, body, setCookie } = await this.makeCaptchaAPICall(netaceaCookie, clientIP, userAgent, captchaData);
-        return this.composeResult(body, setCookie, status, match, mitigate, captcha, true);
-    }
-    async getMitataCaptchaFromHeaders(headers) {
-        if (Object.prototype.hasOwnProperty.call(headers, netaceaintegrationbase_1.dictionary.netaceaHeaders.mitataCaptcha)) {
-            const mitataCaptcha = headers[netaceaintegrationbase_1.dictionary.netaceaHeaders.mitataCaptcha];
-            const mitataCaptchaExpiry = parseInt(headers[netaceaintegrationbase_1.dictionary.netaceaHeaders.mitataCaptchaExpiry]);
-            const mitataCaptchaCookie = await this.buildCookieFromValues(this.netaceaCaptchaCookieName, mitataCaptcha, mitataCaptchaExpiry);
-            if (mitataCaptchaCookie !== undefined) {
-                return mitataCaptchaCookie;
-            }
-        }
-        return undefined;
-    }
-    async makeCaptchaAPICall(netaceaCookie, clientIP, userAgent, captchaData) {
-        const headers = {
-            'X-Netacea-API-Key': this.apiKey,
-            'X-Netacea-Client-IP': clientIP,
-            'user-agent': userAgent,
-            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
-        };
-        const mitata = (0, netaceaintegrationbase_1.matchMitataCookie)(netaceaCookie);
-        if (mitata !== undefined) {
-            headers['X-Netacea-UserId'] = mitata.userId;
-        }
-        if (this.captchaSiteKey !== undefined && this.captchaSecretKey !== undefined) {
-            headers['X-Netacea-Captcha-Site-Key'] = this.captchaSiteKey;
-            headers['X-Netacea-Captcha-Secret-Key'] = this.captchaSecretKey;
-        }
-        const res = await this.makeRequest({
-            host: this.mitigationServiceUrl,
-            path: '/AtaVerifyCaptcha',
-            headers,
-            method: 'POST',
-            body: captchaData,
-            timeout: this.timeout
-        });
-        return await this.getApiCallResponseFromResponse(res, mitata === null || mitata === void 0 ? void 0 : mitata.userId, clientIP);
-    }
-    async getApiCallResponseFromResponse(response, userId, clientIP) {
-        var _a, _b, _c, _d, _f, _g;
-        if (response.status !== 200) {
-            throw this.APIError(response);
-        }
-        // TODO: why does .toString() fix this?
-        const match = (_b = (_a = response.headers[netaceaintegrationbase_1.dictionary.netaceaHeaders.match]) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : '0';
-        const mitigate = (_d = (_c = response.headers[netaceaintegrationbase_1.dictionary.netaceaHeaders.mitigate]) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : '0';
-        const captcha = (_g = (_f = response.headers[netaceaintegrationbase_1.dictionary.netaceaHeaders.captcha]) === null || _f === void 0 ? void 0 : _f.toString()) !== null && _g !== void 0 ? _g : '0';
-        let mitataMaxAge = parseInt(response.headers[netaceaintegrationbase_1.dictionary.netaceaHeaders.mitataExpiry]);
-        if (isNaN(mitataMaxAge)) {
-            mitataMaxAge = 86400;
-        }
-        const mitata = await this.createMitata(clientIP, userId, match, mitigate, captcha);
-        const mitataCaptcha = await this.getMitataCaptchaFromHeaders(response.headers);
-        const setCookie = [
-            mitata,
-            mitataCaptcha
-        ].filter(c => c !== undefined);
-        const eventId = response.headers[netaceaintegrationbase_1.dictionary.netaceaHeaders.eventId];
-        return {
-            status: response.status,
-            match,
-            mitigate,
-            captcha,
-            setCookie,
-            body: response.body,
-            eventId,
-            mitataMaxAge
-        };
-    }
-    async buildCookieFromValues(cookieName, value, maxAge, path = '/') {
-        if (this.encryptedCookies.includes(cookieName)) {
-            const encyptedValue = await this.encryptCookieValue(value);
-            return `${cookieName}=${encyptedValue}; Max-Age=${maxAge}; Path=${path}`;
-        }
-        return `${cookieName}=${value}; Max-Age=${maxAge}; Path=${path}`;
-    }
-    buildCookieHeader(cookies) {
-        let cookiestr = '';
-        let separator = '';
-        for (const cookie in cookies) {
-            const cookieValue = cookies[cookie];
-            if (cookieValue !== undefined) {
-                cookiestr = `${cookiestr}${separator}${cookie}=${cookieValue}`;
-                separator = '; ';
-            }
-        }
-        return cookiestr;
-    }
-    async makeMitigateAPICall(userId, clientIP, userAgent, captchaCookie) {
-        const headers = {
-            'X-Netacea-API-Key': this.apiKey,
-            'X-Netacea-Client-IP': clientIP,
-            'user-agent': userAgent,
-            cookie: this.buildCookieHeader({
-                _mitatacaptcha: captchaCookie
-            })
-        };
-        if (userId !== undefined) {
-            headers['X-Netacea-UserId'] = userId;
-        }
-        if (this.captchaSiteKey !== undefined && this.captchaSecretKey !== undefined) {
-            headers['X-Netacea-Captcha-Site-Key'] = this.captchaSiteKey;
-            headers['X-Netacea-Captcha-Secret-Key'] = this.captchaSecretKey;
-        }
-        const res = await this.makeRequest({
-            host: this.mitigationServiceUrl,
-            path: '/',
-            headers,
-            method: 'GET',
-            timeout: this.timeout
-        });
-        return await this.getApiCallResponseFromResponse(res, userId, clientIP);
-    }
-    composeResult(body, setCookie, status, match, mitigate, captcha, isCaptchaPost, eventId) {
-        const bestMitigation = this.findBestMitigation(match, mitigate, captcha, isCaptchaPost);
-        const result = {
-            body,
-            apiCallStatus: status,
-            setCookie,
-            sessionStatus: bestMitigation.sessionStatus,
-            mitigation: bestMitigation.mitigation,
-            mitigated: [
-                netaceaintegrationbase_1.dictionary.mitigationTypes.block,
-                netaceaintegrationbase_1.dictionary.mitigationTypes.captcha,
-                netaceaintegrationbase_1.dictionary.mitigationTypes.captchaPass
-            ].includes(bestMitigation.mitigation)
-        };
-        if (this.mitigationType === netaceaintegrationbase_1.NetaceaMitigationType.INJECT) {
-            const injectHeaders = {
-                'x-netacea-match': bestMitigation.parts.match.toString(),
-                'x-netacea-mitigate': bestMitigation.parts.mitigate.toString(),
-                'x-netacea-captcha': bestMitigation.parts.captcha.toString()
-            };
-            if (eventId !== undefined) {
-                injectHeaders['x-netacea-event-id'] = eventId;
-            }
-            result.injectHeaders = injectHeaders;
-        }
-        return result;
-    }
-    findBestMitigation(match, mitigate, captcha, isCaptchaPost) {
-        var _a, _b, _c;
-        const UNKNOWN = 'unknown';
-        if (!isCaptchaPost) {
-            if (captcha === '2') {
-                captcha = '4';
-            }
-            else if (captcha === '3') {
-                captcha = '5';
-            }
-        }
-        let sessionStatus = (_a = netaceaintegrationbase_1.dictionary.matchMap[match]) !== null && _a !== void 0 ? _a : (UNKNOWN + '_');
-        sessionStatus += (_b = netaceaintegrationbase_1.dictionary.mitigateMap[mitigate]) !== null && _b !== void 0 ? _b : UNKNOWN;
-        let mitigation = netaceaintegrationbase_1.dictionary.bestMitigationMap[mitigate];
-        if (captcha !== '0') {
-            sessionStatus += ',' + ((_c = netaceaintegrationbase_1.dictionary.captchaMap[captcha]) !== null && _c !== void 0 ? _c : UNKNOWN);
-            const bestCaptchaMitigation = netaceaintegrationbase_1.dictionary.bestMitigationCaptchaMap[captcha];
-            if (bestCaptchaMitigation !== undefined) {
-                mitigation = bestCaptchaMitigation;
-            }
-        }
-        if (this.mitigationType === netaceaintegrationbase_1.NetaceaMitigationType.INJECT) {
-            mitigation = netaceaintegrationbase_1.dictionary.mitigationTypes.none;
-        }
-        return {
-            sessionStatus,
-            mitigation,
-            parts: {
-                match,
-                mitigate,
-                captcha
-            }
-        };
-    }
-    APIError(response) {
-        let message = 'Unknown error';
-        switch (response.status) {
-            case 403:
-                message = 'Invalid credentials';
-                break;
-            case 500:
-                message = 'Server error';
-                break;
-            case 502:
-                message = 'Bad Gateway';
-                break;
-            case 503:
-                message = 'Service Unavailable';
-                break;
-            case 400:
-                message = 'Invalid request';
-                break;
-        }
-        return new Error(`Error reaching Netacea API (${message}), status: ${response.status}`);
-    }
-    isUrlCaptchaPost(url, method) {
-        return url.includes('/AtaVerifyCaptcha') && method.toLowerCase() === 'post';
-    }
-    async processMitigateRequest(args) {
-        const isCaptchaPost = this.isUrlCaptchaPost(args.url, args.method);
-        return await (isCaptchaPost
-            ? this.processCaptcha(args.mitata, args.clientIp, args.userAgent, await args.getBodyFn())
-            : this.check(args.mitata, args.clientIp, args.userAgent, args.mitataCaptcha));
-    }
-    async setIngestOnlyMitataCookie(userId) {
-        const mitataCookie = await this.createMitata(netaceaintegrationbase_1.ingestIgnoredIpValue, userId, '0', '0', '0', ONE_DAY_IN_SECONDS);
-        return {
-            sessionStatus: '',
-            setCookie: [mitataCookie]
-        };
-    }
-    async processIngest(args) {
-        var _a;
-        if (this.secretKey === undefined) {
-            throw new Error('Secret key is required for ingest');
-        }
-        const cookies = this.getCookieHeader(args);
-        const netaceaCookie = await this.readCookie(this.netaceaCookieName, cookies);
-        const cookieInfo = (0, netaceaintegrationbase_1.checkMitataCookie)(netaceaCookie, netaceaintegrationbase_1.ingestIgnoredIpValue, this.secretKey);
-        if (!cookieInfo.isPrimaryHashValid) {
-            return await this.setIngestOnlyMitataCookie(undefined);
-        }
-        if (cookieInfo.requiresReissue) {
-            return await this.setIngestOnlyMitataCookie((_a = cookieInfo.mitata) === null || _a === void 0 ? void 0 : _a.userId);
-        }
-        return {
-            sessionStatus: '',
-            setCookie: []
-        };
-    }
-    async encryptCookieValue(cookieValue) {
-        return cookieValue;
-    }
-    async decryptCookieValue(encryptedCookieValue) {
-        return encryptedCookieValue;
-    }
-}
-class F5 extends NetaceaBase {
-    constructor(args) {
-        var _a, _b;
-        super(args);
-        if (args.maxSockets === undefined) {
-            args.maxSockets = 25;
-        }
-        this.httpsAgent = new https.Agent({
-            timeout: this.timeout,
-            keepAlive: true,
-            maxSockets: args.maxSockets
-        });
-        this.mitataCookieName = (_a = args.netaceaCookieName) !== null && _a !== void 0 ? _a : '_mitata';
-        this.mitataCaptchaCookieName = (_b = args.netaceaCaptchaCookieName) !== null && _b !== void 0 ? _b : '_mitatacaptcha';
-    }
-    getInjectHeaders(netaceaResult) {
-        var _a, _b, _c, _d;
-        if (this.mitigationType === netaceaintegrationbase_1.NetaceaMitigationType.INJECT) {
-            const injectRes = netaceaResult;
-            if (injectRes.injectHeaders !== undefined) {
-                return [
-                    (_a = injectRes.injectHeaders['x-netacea-match']) !== null && _a !== void 0 ? _a : '0',
-                    (_b = injectRes.injectHeaders['x-netacea-mitigate']) !== null && _b !== void 0 ? _b : '0',
-                    (_c = injectRes.injectHeaders['x-netacea-captcha']) !== null && _c !== void 0 ? _c : '0',
-                    (_d = injectRes.injectHeaders['x-netacea-event-id']) !== null && _d !== void 0 ? _d : ''
-                ];
-            }
-        }
-        return [];
-    }
-    registerMitigateHandler(ilx) {
-        ilx.addMethod('handleRequest', async (req, res) => {
-            const params = req.params();
-            const [ip, userAgent, method, url, cookieHeader] = params;
-            const body = params.length === 6 ? this.getArrayValueOrDefault(params, 5, undefined) : undefined;
-            try {
-                const [mitataCookie, mitataCaptchaCookie] = this.getMitataCookies(cookieHeader);
-                const netaceaResult = await this.runMitigation({
-                    ip,
-                    method,
-                    url,
-                    mitataCaptchaCookie,
-                    mitataCookie,
-                    userAgent,
-                    body
-                });
-                if ((netaceaResult === null || netaceaResult === void 0 ? void 0 : netaceaResult.sessionStatus) === 'error_open') {
-                    res.reply(['', 500, [], 'error_open', true, '', []]);
-                    return;
-                }
-                if (netaceaResult === undefined) {
-                    res.reply(['', 0, [], '', false, '', []]);
-                    return;
-                }
-                let responseBody = '';
-                let apiCallStatus = 0;
-                let mitigated = false;
-                let mitata = this.getValueOrDefault(mitataCookie, '');
-                if (netaceaResult.setCookie !== undefined && netaceaResult.setCookie.length > 0) {
-                    const mitataCookie = netaceaResult.setCookie.find(f => f.includes(`${this.netaceaCookieName}=`));
-                    if (mitataCookie !== undefined) {
-                        mitata = mitataCookie.split(';')[0].replace(`${this.netaceaCookieName}=`, '');
-                    }
-                }
-                if (netaceaResult.response !== undefined) {
-                    apiCallStatus = netaceaResult.response.apiCallStatus;
-                    responseBody = this.getValueOrDefault(netaceaResult.response.body, 'Forbidden');
-                    mitigated = this.getValueOrDefault(netaceaResult.response.mitigated, mitigated);
-                }
-                res.reply([
-                    responseBody,
-                    apiCallStatus,
-                    this.getValueOrDefault(netaceaResult.setCookie, []),
-                    netaceaResult.sessionStatus,
-                    mitigated,
-                    this.getValueOrDefault(mitata, ''),
-                    this.getInjectHeaders(netaceaResult)
-                ]);
-            }
-            catch (err) {
-                console.error('Could not reach Netacea mitigation API: ', err.message);
-                res.reply(['', 0, [], '', false, '', []]);
-            }
-        });
-    }
-    getValueOrDefault(value, defaultVal) {
-        return value !== null && value !== void 0 ? value : defaultVal;
-    }
-    getArrayValueOrDefault(args, index, defaultVal) {
-        var _a;
-        return (_a = args[index]) !== null && _a !== void 0 ? _a : defaultVal;
-    }
-    getMitataCookies(cookieHeader) {
-        const cookies = cookieHeader === null || cookieHeader === void 0 ? void 0 : cookieHeader.split('; ');
-        const mitataCookie = this.getCookie(this.mitataCookieName, cookies);
-        const mitataCaptchaCookie = this.getCookie(this.mitataCaptchaCookieName, cookies);
-        return [mitataCookie, mitataCaptchaCookie];
-    }
-    getCookie(cookieName, cookies) {
-        var _a;
-        return (_a = cookies === null || cookies === void 0 ? void 0 : cookies.find(c => c.includes(`${cookieName}=`))) === null || _a === void 0 ? void 0 : _a.replace(`${cookieName}=`, '');
-    }
-    registerIngestHandler(ilx) {
-        ilx.addMethod('ingest', (req, res) => {
-            const params = req.params();
-            const ip = this.getArrayValueOrDefault(params, 0, '');
-            const userAgent = this.getArrayValueOrDefault(params, 1, '');
-            const status = this.getArrayValueOrDefault(params, 2, '-1');
-            const method = this.getArrayValueOrDefault(params, 3, '');
-            const path = this.getArrayValueOrDefault(params, 4, '');
-            const protocol = this.getArrayValueOrDefault(params, 5, '');
-            const referer = this.getArrayValueOrDefault(params, 6, '');
-            const bytesSent = this.getArrayValueOrDefault(params, 7, '0');
-            const requestTime = this.getArrayValueOrDefault(params, 8, '0');
-            const mitataCookie = this.getArrayValueOrDefault(params, 9, '');
-            const sessionStatus = this.getArrayValueOrDefault(params, 10, '');
-            this.ingest({
-                ip, userAgent, status, method, path, protocol, referer, bytesSent, requestTime, mitataCookie, sessionStatus
-            }).catch((err) => {
-                console.error('Could not reach Netacea ingest API: ' + err.message);
-            });
-            res.reply('done');
-        });
-    }
-    async makeRequest(args) {
-        return await new Promise((resolve, reject) => {
-            args.host = args.host.replace('https://', '');
-            // @ts-expect-error no body exists in type
-            const request = https.request({
-                agent: this.httpsAgent,
-                host: args.host,
-                path: args.path,
-                headers: args.headers,
-                method: args.method,
-                body: args.body
-            }, (res) => {
-                let body = '';
-                res.on('data', (data) => {
-                    body += data;
-                });
-                res.on('end', () => {
-                    var _a;
-                    resolve({
-                        headers: res.headers,
-                        status: (_a = res.statusCode) !== null && _a !== void 0 ? _a : 0,
-                        body: body === '' ? undefined : body
-                    });
-                });
-            });
-            const events = ['error', 'abort', 'timeout'];
-            for (const e of events) {
-                request.on(e, (err) => {
-                    reject(err);
-                    // This is a boolean, typedefs are a bit out of date
-                    // https://nodejs.org/api/http.html#http_request_aborted
-                    if (!request.destroyed) {
-                        request.destroy();
-                    }
-                });
-            }
-            if (args.method.toLowerCase() === 'post') {
-                request.write(args.body);
-            }
-            request.end();
-        });
-    }
-    async mitigate(args) {
-        var _a, _b;
-        const check = await this.getMitigationResponse(args);
-        const response = {
-            sessionStatus: check.sessionStatus,
-            setCookie: check.setCookie
-        };
-        if (check.mitigated) {
-            response.response = {
-                body: (_a = check.body) !== null && _a !== void 0 ? _a : 'Forbidden',
-                status: 403,
-                apiCallStatus: (_b = check.apiCallStatus) !== null && _b !== void 0 ? _b : -1,
-                mitigation: check.mitigation,
-                mitigated: check.mitigated
-            };
-        }
-        return response;
-    }
-    async inject(args) {
-        const check = await this.getMitigationResponse(args);
-        return {
-            injectHeaders: check.injectHeaders,
-            sessionStatus: check.sessionStatus,
-            setCookie: check.setCookie
-        };
-    }
-    async getMitigationResponse({ ip, userAgent, url, method, mitataCookie, mitataCaptchaCookie, body }) {
-        return await this.processMitigateRequest({
-            clientIp: ip,
-            getBodyFn: async () => await Promise.resolve(body),
-            method,
-            mitata: mitataCookie,
-            mitataCaptcha: mitataCaptchaCookie,
-            url,
-            userAgent
-        });
-    }
-    async ingest({ ip, userAgent, status, method, path, protocol, referer, bytesSent, requestTime, mitataCookie, sessionStatus }) {
-        await this.callIngest({
-            ip,
-            userAgent,
-            status,
-            method,
-            bytesSent,
-            path,
-            protocol,
-            referer,
-            requestTime,
-            mitataCookie,
-            sessionStatus,
-            integrationType: pack.name.replace('@netacea/', ''),
-            integrationVersion: pack.version
-        });
-    }
-    getCookieHeader(args) {
-        if (args.mitataCookie !== undefined) {
-            return `${this.mitataCookieName}=${args.mitataCookie}`;
-        }
-        return undefined;
-    }
-}
-exports.default = F5;
-//# sourceMappingURL=F5.js.map