@netacea/cloudfront 5.2.54 → 6.0.1

package/dist/src/Cloudfront.js

@@ -1,954 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const netaceaintegrationbase_1 = require("@netacea/netaceaintegrationbase");
-const pack = require("../package.json");
-const axios_1 = require("axios");
-const kinesisingest_1 = require("@netacea/kinesisingest");
-const cookieEncryption_1 = require("./cookieEncryption");
-const captchaGet_1 = require("./captchaGet");
-const dynamicContentType_1 = require("./dynamicContentType");
-const retrieveClientIp_1 = require("./retrieveClientIp");
-const headers_1 = require("./headers");
-const { extractCookieAttr, extractAndRemoveCookieAttr, removeDuplicateAttrs } = netaceaintegrationbase_1.lib.cookie.attributes;
-const parseSetCookie = netaceaintegrationbase_1.lib.cookie.parse.parseSetCookie;
-const { configureCookiesDomain } = netaceaintegrationbase_1.lib.cookie.attributes;
-const { matchMap, mitigationTypes, mitigateMap, bestMitigationMap, bestMitigationCaptchaMap, captchaMap, netaceaHeaders } = netaceaintegrationbase_1.dictionary;
-const ONE_HOUR_IN_SECONDS = 60 * 60;
-const ONE_DAY_IN_SECONDS = ONE_HOUR_IN_SECONDS * 24;
-class Cloudfront {
-    constructor(options) {
-        var _a, _b, _c, _d, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
-        this.ingestEnabled = true;
-        this.encryptedCookies = [];
-        // Only kinesis ingest is currently supported.
-        options.ingestType = netaceaintegrationbase_1.NetaceaIngestType.KINESIS;
-        if (options.kinesis === undefined) {
-            console.warn([
-                'NETACEA :: Please move kinesis params to "kinesis" object in config.',
-                'Backwards compatibility will soon be removed.'
-            ].join(' '));
-            options.kinesis = {
-                kinesisStreamName: options.kinesisStreamName,
-                kinesisAccessKey: options.kinesisAccessKey,
-                kinesisSecretKey: options.kinesisSecretKey,
-                maxLogAgeSeconds: 1
-            };
-        }
-        if (options.apiKey === null || options.apiKey === undefined) {
-            throw new Error('apiKey is a required parameter');
-        }
-        this.apiKey = options.apiKey;
-        this.secretKey = options.secretKey;
-        this.mitigationServiceUrl = (_a = options.mitigationServiceUrl) !== null && _a !== void 0 ? _a : 'https://mitigations.netacea.net';
-        this.ingestServiceUrl = (_b = options.ingestServiceUrl) !== null && _b !== void 0 ? _b : 'https://ingest.netacea.net';
-        this.mitigationType = (_c = options.mitigationType) !== null && _c !== void 0 ? _c : netaceaintegrationbase_1.NetaceaMitigationType.INGEST;
-        this.ingestType = (_d = options.ingestType) !== null && _d !== void 0 ? _d : netaceaintegrationbase_1.NetaceaIngestType.HTTP;
-        this.logVersion = (_f = options.logVersion) !== null && _f !== void 0 ? _f : netaceaintegrationbase_1.NetaceaLogVersion.V1;
-        if (this.ingestType === netaceaintegrationbase_1.NetaceaIngestType.KINESIS) {
-            if (options.kinesis === undefined) {
-                console.warn(`NETACEA WARN: no kinesis args provided, when ingestType is ${this.ingestType}`);
-            }
-            else {
-                this.kinesis = new kinesisingest_1.default({
-                    ...options.kinesis,
-                    apiKey: this.apiKey
-                });
-            }
-        }
-        if (options.captchaSiteKey !== undefined || options.captchaSecretKey !== undefined) {
-            this.captchaSiteKey = options.captchaSiteKey;
-            this.captchaSecretKey = options.captchaSecretKey;
-        }
-        this.timeout = (0, netaceaintegrationbase_1.correctTimeout)((_g = options.timeout) !== null && _g !== void 0 ? _g : 3000);
-        this.netaceaCookieName = (_h = options.netaceaCookieName) !== null && _h !== void 0 ? _h : '_mitata';
-        this.netaceaCaptchaCookieName = (_j = options.netaceaCaptchaCookieName) !== null && _j !== void 0 ? _j : '_mitatacaptcha';
-        this.netaceaCaptchaPath = options.netaceaCaptchaPath;
-        this.dynamicCaptchaContentType = (_k = options.dynamicCaptchaContentType) !== null && _k !== void 0 ? _k : false;
-        const configuredCookieAttributes = configureCookiesDomain((_l = options.netaceaCookieAttributes) !== null && _l !== void 0 ? _l : '', (_m = options.netaceaCaptchaCookieAttributes) !== null && _m !== void 0 ? _m : '');
-        this.netaceaCookieAttributes = (_o = configuredCookieAttributes.cookieAttributes) !== null && _o !== void 0 ? _o : '';
-        this.netaceaCaptchaCookieAttributes = (_p = configuredCookieAttributes.captchaCookieAttributes) !== null && _p !== void 0 ? _p : '';
-        this.captchaHeader = options.captchaHeader;
-        this.ipHeaderName = (_r = (_q = options.ipHeaderName) === null || _q === void 0 ? void 0 : _q.toLowerCase()) === null || _r === void 0 ? void 0 : _r.trim();
-        this.encryptedCookies = [
-            this.netaceaCookieName,
-            this.netaceaCaptchaCookieName
-        ];
-        this.mitataCookieExpirySeconds = (0, netaceaintegrationbase_1.configureMitataExpiry)(this.mitigationType, (_s = options.netaceaCookieExpirySeconds) !== null && _s !== void 0 ? _s : options.mitataCookieExpirySeconds);
-        this.ingestEnabled = (_t = options.ingestEnabled) !== null && _t !== void 0 ? _t : true;
-        this.cookieEncryptionKey = options.cookieEncryptionKey;
-    }
-    async run(cloudfrontEvent) {
-        try {
-            const { uri, method } = this.getRequestResponseFromEvent(cloudfrontEvent).request;
-            if (this.isUrlCaptchaGet(uri, method)) {
-                const response = await (0, captchaGet_1.handleCaptchaGetRequest)({
-                    event: cloudfrontEvent,
-                    secretKey: this.secretKey,
-                    mitigationCallFn: this.makeMitigateAPICall.bind(this),
-                    composeResultFn: this.composeResult.bind(this),
-                    cookieEncryptionKey: this.cookieEncryptionKey,
-                    netaceaCookieName: this.netaceaCookieName,
-                    netaceaCaptchaCookieName: this.netaceaCaptchaCookieName,
-                    ipHeaderName: this.ipHeaderName
-                });
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                this.ingest(response);
-                return response;
-            }
-            const netaceaResult = await this.runMitigation(cloudfrontEvent);
-            const { request } = this.getRequestResponseFromEvent(cloudfrontEvent);
-            this.addNetaceaCookiesToRequest(request, netaceaResult);
-            request.headers[Cloudfront.NetaceaTrueUserAgentHeader] = [{
-                    key: Cloudfront.NetaceaTrueUserAgentHeader,
-                    value: this.getValueFromHeaderOrDefault(request.headers, 'user-agent', '-')
-                }];
-            if ((netaceaResult === null || netaceaResult === void 0 ? void 0 : netaceaResult.response) !== undefined) {
-                cloudfrontEvent.Records[0].cf.response = netaceaResult.response;
-            }
-            return cloudfrontEvent;
-        }
-        catch (err) {
-            console.error('Netacea FailOpen - ', err.message);
-            return cloudfrontEvent;
-        }
-    }
-    async makeRequest({ host, path, method, body, headers, timeout }) {
-        const url = `${host}${path}`;
-        const data = await axios_1.default.request({
-            url,
-            data: body,
-            headers,
-            method,
-            timeout,
-            transformResponse: (data) => data
-        });
-        return {
-            headers: data.headers,
-            status: data.status,
-            body: data.data
-        };
-    }
-    async mitigate(cloudfrontEvent) {
-        var _a;
-        try {
-            const { netaceaResult, request } = await this.getMitigationResponse(cloudfrontEvent);
-            let res;
-            if (netaceaResult.mitigated) {
-                const headers = {
-                    'set-cookie': []
-                };
-                for (const cookie of netaceaResult.setCookie) {
-                    headers['set-cookie'] = (_a = headers['set-cookie']) !== null && _a !== void 0 ? _a : [];
-                    headers['set-cookie'].push({
-                        key: 'set-cookie',
-                        value: cookie
-                    });
-                }
-                if (netaceaResult.mitigation === 'captcha' && this.captchaHeader !== undefined) {
-                    headers[this.captchaHeader.name] = [{
-                            key: this.captchaHeader.name,
-                            value: this.captchaHeader.value
-                        }];
-                }
-                const responseStatus = this.isUrlCaptchaPost(request.uri, request.method)
-                    ? {
-                        status: '200',
-                        statusDescription: 'OK',
-                        body: ''
-                    }
-                    : {
-                        status: '403',
-                        statusDescription: 'Forbidden',
-                        body: 'Forbidden'
-                    };
-                res = {
-                    headers,
-                    ...responseStatus
-                };
-                let len = 0;
-                if (netaceaResult.body !== undefined && netaceaResult.body.length > 0) {
-                    len = netaceaResult.body.length;
-                    const isCaptchaJson = (0, dynamicContentType_1.isCaptchaJsonResponse)(netaceaResult.body);
-                    // lambdas won't let you set body on 403 status codes
-                    res.status = isCaptchaJson ? '403' : '200';
-                    res.statusDescription = isCaptchaJson ? 'Forbidden' : 'OK';
-                    res.body = netaceaResult.body;
-                    res.bodyEncoding = 'text';
-                }
-                // We have to ingest here because viewer response doesn't get called
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                this.ingest({
-                    Records: [{
-                            cf: {
-                                request,
-                                response: {
-                                    status: res.status,
-                                    headers: {
-                                        'content-length': [
-                                            {
-                                                key: 'content-length',
-                                                value: len.toString()
-                                            }
-                                        ],
-                                        'set-cookie': netaceaResult.setCookie.map(cookie => {
-                                            return {
-                                                key: 'set-cookie',
-                                                value: cookie
-                                            };
-                                        })
-                                    }
-                                }
-                            }
-                        }]
-                });
-            }
-            this.addNetaceaCookiesToRequest(request, netaceaResult);
-            return {
-                response: res,
-                sessionStatus: netaceaResult.sessionStatus,
-                setCookie: netaceaResult.setCookie
-            };
-        }
-        catch (err) {
-            console.error('Netacea FailOpen Error: ', err);
-            return {
-                sessionStatus: ''
-            };
-        }
-    }
-    async inject(cloudfrontEvent) {
-        try {
-            const { netaceaResult } = await this.getMitigationResponse(cloudfrontEvent);
-            return {
-                injectHeaders: netaceaResult.injectHeaders,
-                sessionStatus: netaceaResult.sessionStatus,
-                setCookie: netaceaResult.setCookie
-            };
-        }
-        catch (err) {
-            console.error('Netacea FailOpen Error: ', err);
-            return {
-                sessionStatus: '',
-                injectHeaders: undefined,
-                setCookie: undefined
-            };
-        }
-    }
-    async ingest(cloudfrontEvent) {
-        var _a, _b, _c;
-        if (!this.ingestEnabled) {
-            return;
-        }
-        const { request, response } = this.getRequestResponseFromEvent(cloudfrontEvent);
-        if (response === undefined) {
-            throw new Error('Cloudfront response is required to ingest');
-        }
-        const setCookie = this.getMitataValueFromHeaderOrDefault(response.headers, 'set-cookie');
-        const cookieString = setCookie !== ''
-            ? setCookie
-            : this.getMitataValueFromHeaderOrDefault(request.headers, 'cookie');
-        let mitata = (_a = await this.readCookie(this.netaceaCookieName, cookieString)) !== null && _a !== void 0 ? _a : '';
-        if (mitata === undefined || mitata === '') {
-            const cookieString = this.getMitataValueFromHeaderOrDefault(request.headers, 'cookie');
-            mitata = (_b = await this.readCookie(this.netaceaCookieName, cookieString)) !== null && _b !== void 0 ? _b : '';
-        }
-        let match = 0;
-        let mitigate = 0;
-        let captcha = 0;
-        const mitataBits = (0, netaceaintegrationbase_1.matchMitataCookie)(mitata);
-        if (mitataBits !== undefined) {
-            match = mitataBits.match;
-            mitigate = mitataBits.mitigate;
-            captcha = mitataBits.captcha;
-        }
-        const isCaptchaPass = this.shouldSetCaptchaPass(cloudfrontEvent);
-        const { sessionStatus } = this.findBestMitigation(match, mitigate, captcha, isCaptchaPass);
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        await this.callIngest({
-            bytesSent: this.getValueFromHeaderOrDefault(response.headers, 'content-length', '0'),
-            ip: (0, retrieveClientIp_1.retrieveClientIp)(cloudfrontEvent, this.ipHeaderName),
-            method: request.method,
-            path: request.uri,
-            protocol: (_c = request.httpVersion) !== null && _c !== void 0 ? _c : 'HTTP/1.1',
-            referer: this.getValueFromHeaderOrDefault(request.headers, 'referer'),
-            requestTime: '0',
-            status: response.status,
-            userAgent: this.getValueFromHeaderOrDefault(request.headers, Cloudfront.NetaceaTrueUserAgentHeader, this.getValueFromHeaderOrDefault(request.headers, 'user-agent')),
-            mitataCookie: mitata,
-            sessionStatus,
-            integrationType: pack.name.replace('@netacea/', ''),
-            integrationVersion: pack.version,
-            xForwardedFor: this.getValueFromHeaderOrDefault(request.headers, 'x-forwarded-for')
-        });
-    }
-    addNetaceaCookiesToResponse(cloudfrontEvent) {
-        const { response, request } = this.getRequestResponseFromEvent(cloudfrontEvent);
-        if (response === undefined) {
-            throw new Error('Response required to add cookies to response');
-        }
-        const headers = request.headers[Cloudfront.NetaceaCookieHeader];
-        if (headers !== undefined) {
-            let setCookieIncludesNetaceaCookies = false;
-            if (response.headers['set-cookie'] === undefined) {
-                response.headers['set-cookie'] = [];
-            }
-            else {
-                setCookieIncludesNetaceaCookies = response.headers['set-cookie'].find(v => {
-                    return v.value.includes(this.netaceaCookieName) || v.value.includes(this.netaceaCaptchaCookieName);
-                }) !== undefined;
-            }
-            if (!setCookieIncludesNetaceaCookies) {
-                for (const header of headers) {
-                    response.headers['set-cookie'].push({
-                        key: 'set-cookie',
-                        value: header.value
-                    });
-                }
-            }
-        }
-        this.setInjectHeaders(cloudfrontEvent);
-    }
-    setInjectHeaders(cloudfrontEvent) {
-        const { response, request } = this.getRequestResponseFromEvent(cloudfrontEvent);
-        if (response !== undefined) {
-            const match = request.headers['x-netacea-match'];
-            const mitigate = request.headers['x-netacea-mitigate'];
-            const captcha = request.headers['x-netacea-captcha'];
-            const eventId = request.headers['x-netacea-event-id'];
-            if (match !== undefined &&
-                mitigate !== undefined &&
-                captcha !== undefined) {
-                response.headers['x-netacea-match'] = match;
-                response.headers['x-netacea-mitigate'] = mitigate;
-                response.headers['x-netacea-captcha'] = this.shouldSetCaptchaPass(cloudfrontEvent)
-                    ? [{
-                            key: 'x-netacea-captcha',
-                            value: '2'
-                        }]
-                    : captcha;
-            }
-            if (eventId !== undefined) {
-                response.headers['x-netacea-event-id'] = eventId;
-            }
-        }
-    }
-    getValueFromHeaderOrDefault(headers, key, def = '') {
-        if (headers[key] !== undefined) {
-            const v = headers[key];
-            if (v !== undefined) {
-                return v[0].value;
-            }
-        }
-        return def;
-    }
-    getMitataValueFromHeaderOrDefault(headers, key, def = '') {
-        if (headers[key] !== undefined) {
-            const v = headers[key];
-            if (v !== undefined) {
-                const mitataItem = v.find(x => x.value.includes(this.netaceaCookieName));
-                if (mitataItem !== undefined) {
-                    return mitataItem.value;
-                }
-            }
-        }
-        return def;
-    }
-    getRequestResponseFromEvent(event) {
-        return event.Records[0].cf;
-    }
-    async getMitigationResponse(cloudfrontEvent) {
-        const { request } = this.getRequestResponseFromEvent(cloudfrontEvent);
-        const cookies = this.getMitataValueFromHeaderOrDefault(request.headers, 'cookie');
-        const mitata = await this.readCookie(this.netaceaCookieName, cookies);
-        const mitataCaptcha = await this.readCookie(this.netaceaCaptchaCookieName, cookies);
-        const clientIp = (0, retrieveClientIp_1.retrieveClientIp)(cloudfrontEvent, this.ipHeaderName);
-        const userAgent = this.getValueFromHeaderOrDefault(request.headers, 'user-agent');
-        const accept = this.getValueFromHeaderOrDefault(request.headers, 'accept', 'text/html');
-        const host = this.getValueFromHeaderOrDefault(request.headers, 'host');
-        return {
-            netaceaResult: await this.processMitigateRequest({
-                getBodyFn: async () => { var _a, _b; return await Promise.resolve(Buffer.from((_b = (_a = request.body) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : '', 'base64').toString()); },
-                clientIp,
-                method: request.method,
-                url: request.uri,
-                userAgent,
-                accept,
-                host,
-                mitata,
-                mitataCaptcha
-            }),
-            request
-        };
-    }
-    addNetaceaCookiesToRequest(request, netaceaResult) {
-        var _a, _b;
-        if (netaceaResult === undefined) {
-            return request;
-        }
-        request.headers[Cloudfront.NetaceaCookieHeader] = [];
-        if (netaceaResult.setCookie !== undefined) {
-            for (const cookie of netaceaResult.setCookie) {
-                const cookieHeader = (_a = request.headers[Cloudfront.NetaceaCookieHeader]) !== null && _a !== void 0 ? _a : [];
-                cookieHeader.push({
-                    key: Cloudfront.NetaceaCookieHeader,
-                    value: cookie
-                });
-                request.headers[Cloudfront.NetaceaCookieHeader] = cookieHeader;
-            }
-        }
-        if (this.mitigationType === netaceaintegrationbase_1.NetaceaMitigationType.INJECT) {
-            for (const [key, value] of Object.entries((_b = netaceaResult.injectHeaders) !== null && _b !== void 0 ? _b : {})) {
-                request.headers[key] = [
-                    {
-                        key,
-                        value
-                    }
-                ];
-            }
-        }
-        return request;
-    }
-    getCookieHeader(args) {
-        const { request } = this.getRequestResponseFromEvent(args);
-        return this.getMitataValueFromHeaderOrDefault(request.headers, 'cookie');
-    }
-    async encryptCookieValue(cookieValue) {
-        if (this.cookieEncryptionKey !== undefined) {
-            return await (0, cookieEncryption_1.encrypt)(cookieValue, this.cookieEncryptionKey);
-        }
-        return cookieValue;
-    }
-    async decryptCookieValue(encryptedCookieValue) {
-        if (this.cookieEncryptionKey !== undefined) {
-            return await (0, cookieEncryption_1.decrypt)(encryptedCookieValue, this.cookieEncryptionKey);
-        }
-        return encryptedCookieValue;
-    }
-    /**
-     * START -- NETACEA BASE METHODS
-     */
-    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);
-            return {
-                injectHeaders: {
-                    'x-netacea-captcha': '0',
-                    'x-netacea-match': '0',
-                    'x-netacea-mitigate': '0'
-                },
-                sessionStatus: ''
-            };
-        }
-    }
-    /**
-     * 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 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.accept, args.host, args.mitataCaptcha));
-    }
-    isUrlCaptchaPost(url, method) {
-        return url.includes('/AtaVerifyCaptcha') && method.toLowerCase() === 'post';
-    }
-    isUrlCaptchaGet(url, method) {
-        var _a;
-        return url.toLowerCase() === ((_a = this.netaceaCaptchaPath) === null || _a === void 0 ? void 0 : _a.toLowerCase()) && method.toLowerCase() === 'get';
-    }
-    shouldSetCaptchaPass(cloudfrontEvent) {
-        const { request, response } = this.getRequestResponseFromEvent(cloudfrontEvent);
-        if (this.isUrlCaptchaPost(request.uri, request.method)) {
-            return true;
-        }
-        if (response === undefined) {
-            return false;
-        }
-        const cookies = response.headers['set-cookie'];
-        const mitataCaptcha = cookies === null || cookies === void 0 ? void 0 : cookies.find(cookie => cookie.value.split('=')[0] === this.netaceaCaptchaCookieName);
-        const mitataCaptchaIsSet = mitataCaptcha !== undefined;
-        return this.mitigationType === netaceaintegrationbase_1.NetaceaMitigationType.INJECT && mitataCaptchaIsSet;
-    }
-    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 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, defaultMitataCodes) {
-        var _a, _b, _c, _d, _f, _g, _h;
-        if (response.status !== 200) {
-            throw this.APIError(response);
-        }
-        let match = (_a = (0, headers_1.getHeaderAsInt)(response.headers, netaceaHeaders.match)) !== null && _a !== void 0 ? _a : NaN;
-        let mitigate = (_b = (0, headers_1.getHeaderAsInt)(response.headers, netaceaHeaders.mitigate)) !== null && _b !== void 0 ? _b : NaN;
-        let captcha = (_c = (0, headers_1.getHeaderAsInt)(response.headers, netaceaHeaders.captcha)) !== null && _c !== void 0 ? _c : NaN;
-        if (isNaN(match)) {
-            match = (_d = defaultMitataCodes === null || defaultMitataCodes === void 0 ? void 0 : defaultMitataCodes.match) !== null && _d !== void 0 ? _d : 0;
-        }
-        if (isNaN(mitigate)) {
-            mitigate = (_f = defaultMitataCodes === null || defaultMitataCodes === void 0 ? void 0 : defaultMitataCodes.mitigate) !== null && _f !== void 0 ? _f : 0;
-        }
-        if (isNaN(captcha)) {
-            captcha = (_g = defaultMitataCodes === null || defaultMitataCodes === void 0 ? void 0 : defaultMitataCodes.captcha) !== null && _g !== void 0 ? _g : 0;
-        }
-        let mitataMaxAge = (_h = (0, headers_1.getHeaderAsInt)(response.headers, netaceaHeaders.mitataExpiry)) !== null && _h !== void 0 ? _h : NaN;
-        if (isNaN(mitataMaxAge)) {
-            mitataMaxAge = 86400;
-        }
-        const mitata = await this.createMitata(clientIP, userId, match, mitigate, captcha);
-        const mitataCaptcha = await this.createMitataCaptcha(response.headers);
-        const setCookie = [
-            mitata,
-            mitataCaptcha
-        ].filter(c => c !== undefined);
-        const eventId = (0, headers_1.getHeader)(response.headers, netaceaHeaders.eventId);
-        return {
-            status: response.status,
-            match,
-            mitigate,
-            captcha,
-            setCookie,
-            body: response.body,
-            eventId,
-            mitataMaxAge
-        };
-    }
-    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}`);
-    }
-    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);
-        let maxAgeAttr = maxAge;
-        let path;
-        let finalCookieAttr;
-        if (this.netaceaCookieAttributes !== '') {
-            const { extractedAttribute: exctractedMaxAge, cookieAttributes: cookieAttrsWithoutMaxAge } = extractAndRemoveCookieAttr(this.netaceaCookieAttributes, 'Max-Age');
-            maxAgeAttr = exctractedMaxAge !== undefined ? Number(exctractedMaxAge) : maxAge;
-            const { extractedAttribute: extractedPath, cookieAttributes } = extractAndRemoveCookieAttr(cookieAttrsWithoutMaxAge, 'Path');
-            path = extractedPath !== null && extractedPath !== void 0 ? extractedPath : '/';
-            finalCookieAttr = cookieAttributes !== null && cookieAttributes !== void 0 ? cookieAttributes : undefined;
-        }
-        return await this.buildCookieFromValues(this.netaceaCookieName, mitataValue, maxAgeAttr, finalCookieAttr, path);
-    }
-    async createMitataCaptcha(headers) {
-        var _a, _b;
-        let setCookieHeaders = (_a = headers['set-cookie']) !== null && _a !== void 0 ? _a : [];
-        setCookieHeaders = typeof setCookieHeaders === 'string'
-            ? [setCookieHeaders]
-            : setCookieHeaders;
-        const mitataCaptcha = setCookieHeaders
-            .find(cookie => cookie.startsWith('_mitatacaptcha='));
-        let mitataCaptchaValue;
-        let mitataCaptchaMaxAge = '86400';
-        if (mitataCaptcha !== undefined && mitataCaptcha !== '') {
-            try {
-                const parsed = parseSetCookie(mitataCaptcha);
-                mitataCaptchaValue = parsed.value;
-                mitataCaptchaMaxAge = (_b = extractCookieAttr(parsed.attributes, 'Max-Age')) !== null && _b !== void 0 ? _b : '86400';
-            }
-            catch (e) {
-                return undefined;
-            }
-        }
-        if (mitataCaptchaValue === '' || mitataCaptchaValue === undefined) {
-            return undefined;
-        }
-        const attributes = removeDuplicateAttrs([
-            this.netaceaCaptchaCookieAttributes,
-            'Path=/',
-            `Max-Age=${mitataCaptchaMaxAge}`
-        ]);
-        mitataCaptchaValue = this.encryptedCookies.includes(this.netaceaCaptchaCookieName)
-            ? await this.encryptCookieValue(mitataCaptchaValue)
-            : mitataCaptchaValue;
-        return `${this.netaceaCaptchaCookieName}=${mitataCaptchaValue}; ${attributes}`;
-    }
-    async buildCookieFromValues(cookieName, value, maxAge, cookieAttributes, path = '/') {
-        const cookieValue = this.encryptedCookies.includes(cookieName)
-            ? await this.encryptCookieValue(value)
-            : value;
-        const setCookie = `${cookieName}=${cookieValue}; Max-Age=${maxAge}; Path=${path}`;
-        return cookieAttributes !== undefined && cookieAttributes !== ''
-            ? `${setCookie}; ${cookieAttributes}`
-            : setCookie;
-    }
-    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);
-            }
-        }
-    }
-    constructWebLog(args) {
-        args.bytesSent = args.bytesSent === '' ? '0' : args.bytesSent;
-        if (this.logVersion === netaceaintegrationbase_1.NetaceaLogVersion.V2) {
-            return this.constructV2WebLog(args);
-        }
-        return this.constructV1WebLog(args);
-    }
-    constructV2WebLog({ ip, userAgent, status, method, path, protocol, referer, bytesSent, requestTime, mitataCookie, sessionStatus, integrationType, integrationVersion, xForwardedFor }) {
-        var _a;
-        const now = new Date();
-        // Paths must be prefixed with '/'
-        if (path[0] !== '/') {
-            path = `/${path}`;
-        }
-        let actualQuery;
-        const splitPath = path.split('?');
-        if (splitPath.length > 1) {
-            actualQuery = `?${splitPath[1]}`;
-        }
-        const actualPath = splitPath[0];
-        const userId = (_a = (0, netaceaintegrationbase_1.matchMitataCookie)(mitataCookie)) === null || _a === void 0 ? void 0 : _a.userId;
-        const log = {
-            status,
-            method,
-            bytes_sent: (0, netaceaintegrationbase_1.safeParseInt)(bytesSent),
-            referrer: referer === '' ? undefined : referer,
-            request: `${method} ${actualPath}${actualQuery !== null && actualQuery !== void 0 ? actualQuery : ''} ${protocol}`,
-            request_time: (0, netaceaintegrationbase_1.safeParseInt)(requestTime),
-            integration_type: integrationType,
-            integration_version: integrationVersion,
-            client: ip,
-            user_agent: userAgent,
-            bc_type: sessionStatus === '' ? undefined : sessionStatus,
-            hour: now.getUTCHours(),
-            minute: now.getUTCMinutes(),
-            // '2021-08-04T14:22:41.155Z' = toISOString()
-            '@timestamp': now.toISOString().replace('Z', '+00:00'),
-            path: actualPath,
-            protocol,
-            query: actualQuery,
-            user_id: userId,
-            x_forwarded_for: xForwardedFor
-        };
-        return log;
-    }
-    constructV1WebLog({ ip, userAgent, status, method, path, protocol, referer, bytesSent, requestTime, mitataCookie, sessionStatus, integrationType, integrationVersion, xForwardedFor }) {
-        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 : '',
-            XForwardedFor: xForwardedFor
-        };
-    }
-    async makeIngestApiCall(headers, body) {
-        return await this.makeRequest({
-            host: this.ingestServiceUrl,
-            method: 'POST',
-            path: '/',
-            headers,
-            body: JSON.stringify(body),
-            timeout: this.timeout
-        });
-    }
-    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 setIngestOnlyMitataCookie(userId) {
-        const mitataCookie = await this.createMitata(netaceaintegrationbase_1.ingestIgnoredIpValue, userId, 0, 0, 0, ONE_DAY_IN_SECONDS);
-        return {
-            sessionStatus: '',
-            setCookie: [mitataCookie]
-        };
-    }
-    findBestMitigation(match, mitigate, captcha, isCaptchaPost) {
-        var _a, _b, _c;
-        const UNKNOWN = 'unknown';
-        captcha = this.adjustCaptchaCode(captcha, isCaptchaPost);
-        let sessionStatus = (_a = matchMap[match]) !== null && _a !== void 0 ? _a : (UNKNOWN + '_');
-        sessionStatus += (_b = mitigateMap[mitigate]) !== null && _b !== void 0 ? _b : UNKNOWN;
-        let mitigation = bestMitigationMap[mitigate];
-        if (captcha !== 0) {
-            sessionStatus += ',' + ((_c = captchaMap[captcha]) !== null && _c !== void 0 ? _c : UNKNOWN);
-            const bestCaptchaMitigation = bestMitigationCaptchaMap[captcha];
-            if (bestCaptchaMitigation !== undefined) {
-                mitigation = bestCaptchaMitigation;
-            }
-        }
-        if (this.mitigationType === netaceaintegrationbase_1.NetaceaMitigationType.INJECT) {
-            mitigation = mitigationTypes.none;
-        }
-        return {
-            sessionStatus,
-            mitigation,
-            parts: {
-                match,
-                mitigate,
-                captcha
-            }
-        };
-    }
-    adjustCaptchaCode(captcha, isCaptchaPost) {
-        let adjustedCaptchaCode = captcha;
-        if (!isCaptchaPost) {
-            if (captcha === 2) {
-                adjustedCaptchaCode = 4;
-            }
-            else if (captcha === 3) {
-                adjustedCaptchaCode = 5;
-            }
-        }
-        return adjustedCaptchaCode;
-    }
-    async check(netaceaCookie, clientIP, userAgent, accept, host, 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({
-                userId: (_a = cookieInfo.mitata) === null || _a === void 0 ? void 0 : _a.userId,
-                clientIP,
-                userAgent,
-                captchaCookie,
-                accept,
-                host
-            });
-            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 makeMitigateAPICall({ userId, clientIP, userAgent, captchaCookie, accept, host, isCaptchaGet = false, defaultMitataCodes, trackingId }) {
-        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;
-        }
-        if (this.dynamicCaptchaContentType && this.netaceaCaptchaPath !== undefined) {
-            headers['X-Netacea-Captcha-Content-Type'] = (0, dynamicContentType_1.acceptHeaderToNetaceaContentType)(accept);
-        }
-        const isJsonRequest = headers['X-Netacea-Captcha-Content-Type'] === 'application/json';
-        const trackingIdQuery = trackingId !== undefined ? `?trackingId=${trackingId}` : '';
-        const res = await this.makeRequest({
-            host: this.mitigationServiceUrl,
-            path: isCaptchaGet ? `/captcha${trackingIdQuery}` : '/',
-            headers,
-            method: 'GET',
-            timeout: this.timeout
-        });
-        if (isJsonRequest && this.netaceaCaptchaPath !== undefined) {
-            res.body = (0, dynamicContentType_1.mitSvcJsonResponseToUrlResponse)(res.body, host, this.netaceaCaptchaPath);
-        }
-        return await this.getApiCallResponseFromResponse(res, userId, clientIP, defaultMitataCodes);
-    }
-    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;
-    }
-    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: [
-                mitigationTypes.block,
-                mitigationTypes.captcha,
-                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;
-    }
-}
-Cloudfront.NetaceaCookieHeader = 'x-netacea-cloudfront-mitata-cookie';
-// The `NetaceaTrueUserAgentHeader` header is needed when the Origin server returns an error
-// We need to ingest in OriginResponse, but for some reason cloudfront overrides the header
-Cloudfront.NetaceaTrueUserAgentHeader = 'x-netacea-true-useragent-header';
-exports.default = Cloudfront;
-//# sourceMappingURL=Cloudfront.js.map