@eggjs/cookies 3.0.0

package/dist/esm/cookies.js

@@ -0,0 +1,264 @@
+import assert from 'node:assert';
+import { base64decode, base64encode } from 'utility';
+import { isSameSiteNoneCompatible } from 'should-send-same-site-none';
+import { Keygrip } from './keygrip.js';
+import { Cookie } from './cookie.js';
+import { CookieError } from './error.js';
+const keyCache = new Map();
+/**
+ * cookies for egg
+ * extend pillarjs/cookies, add encrypt and decrypt
+ */
+export class Cookies {
+    #keysArray;
+    #keys;
+    #defaultCookieOptions;
+    #autoChips;
+    ctx;
+    app;
+    secure;
+    #parseChromiumResult;
+    constructor(ctx, keys, defaultCookieOptions) {
+        this.#keysArray = keys;
+        // default cookie options
+        this.#defaultCookieOptions = defaultCookieOptions;
+        this.#autoChips = defaultCookieOptions?.autoChips;
+        this.ctx = ctx;
+        this.secure = this.ctx.secure;
+        this.app = ctx.app;
+    }
+    get keys() {
+        if (!this.#keys) {
+            assert(Array.isArray(this.#keysArray), '.keys required for encrypt/sign cookies');
+            const cache = keyCache.get(this.#keysArray);
+            if (cache) {
+                this.#keys = cache;
+            }
+            else {
+                this.#keys = new Keygrip(this.#keysArray);
+                keyCache.set(this.#keysArray, this.#keys);
+            }
+        }
+        return this.#keys;
+    }
+    /**
+     * get cookie value by name
+     * @param  {String} name - cookie's name
+     * @param  {Object} opts - cookies' options
+     *            - {Boolean} signed - default to true
+     *            - {Boolean} encrypt - default to false
+     * @return {String} value - cookie's value
+     */
+    get(name, opts = {}) {
+        let value = this._get(name, opts);
+        if (value === undefined && this.#autoChips) {
+            // try to read _CHIPS-${name} prefix cookie
+            value = this._get(this.#formatChipsCookieName(name), opts);
+        }
+        return value;
+    }
+    _get(name, opts) {
+        const signed = computeSigned(opts);
+        const header = this.ctx.get('cookie');
+        if (!header)
+            return;
+        const match = header.match(getPattern(name));
+        if (!match)
+            return;
+        let value = match[1];
+        if (!opts.encrypt && !signed)
+            return value;
+        // signed
+        if (signed) {
+            const sigName = name + '.sig';
+            const sigValue = this.get(sigName, { signed: false });
+            if (!sigValue)
+                return;
+            const raw = name + '=' + value;
+            const index = this.keys.verify(raw, sigValue);
+            if (index < 0) {
+                // can not match any key, remove ${name}.sig
+                this.set(sigName, null, { path: '/', signed: false, overwrite: true });
+                return;
+            }
+            if (index > 0) {
+                // not signed by the first key, update sigValue
+                this.set(sigName, this.keys.sign(raw), { signed: false, overwrite: true });
+            }
+            return value;
+        }
+        // encrypt
+        value = base64decode(value, true, 'buffer');
+        const res = this.keys.decrypt(value);
+        return res ? res.value.toString() : undefined;
+    }
+    set(name, value, opts) {
+        opts = {
+            ...this.#defaultCookieOptions,
+            ...opts,
+        };
+        const signed = computeSigned(opts);
+        value = value || '';
+        if (!this.secure && opts.secure) {
+            throw new CookieError('Cannot send secure cookie over unencrypted connection');
+        }
+        let headers = this.ctx.response.get('set-cookie') || [];
+        if (!Array.isArray(headers)) {
+            headers = [headers];
+        }
+        // encrypt
+        if (opts.encrypt) {
+            value = value && base64encode(this.keys.encrypt(value), true);
+        }
+        // http://browsercookielimits.squawky.net/
+        if (value.length > 4093) {
+            this.app.emit('cookieLimitExceed', { name, value, ctx: this.ctx });
+        }
+        // https://github.com/linsight/should-send-same-site-none
+        // fixed SameSite=None: Known Incompatible Clients
+        const userAgent = this.ctx.get('user-agent');
+        let isSameSiteNone = false;
+        // disable autoChips if partitioned enable
+        let autoChips = !opts.partitioned && this.#autoChips;
+        if (opts.sameSite && typeof opts.sameSite === 'string' && opts.sameSite.toLowerCase() === 'none') {
+            isSameSiteNone = true;
+            if (opts.secure === false || !this.secure || (userAgent && !this.isSameSiteNoneCompatible(userAgent))) {
+                // Non-secure context or Incompatible clients, don't send SameSite=None property
+                opts.sameSite = false;
+                isSameSiteNone = false;
+            }
+        }
+        if (autoChips || opts.partitioned) {
+            // allow to set partitioned: secure=true and sameSite=none and chrome >= 118
+            if (!isSameSiteNone || opts.secure === false || !this.secure || (userAgent && !this.isPartitionedCompatible(userAgent))) {
+                // Non-secure context or Incompatible clients, don't send partitioned property
+                autoChips = false;
+                opts.partitioned = false;
+            }
+        }
+        // remove unpartitioned same name cookie first
+        if (opts.partitioned && opts.removeUnpartitioned) {
+            const overwrite = opts.overwrite;
+            if (overwrite) {
+                opts.overwrite = false;
+                headers = ignoreCookiesByName(headers, name);
+            }
+            const removeCookieOpts = Object.assign({}, opts, {
+                partitioned: false,
+            });
+            const removeUnpartitionedCookie = new Cookie(name, '', removeCookieOpts);
+            // if user not set secure, reset secure to ctx.secure
+            if (opts.secure === undefined) {
+                removeUnpartitionedCookie.attrs.secure = this.secure;
+            }
+            headers = pushCookie(headers, removeUnpartitionedCookie);
+            // signed
+            if (signed) {
+                removeUnpartitionedCookie.name += '.sig';
+                headers = ignoreCookiesByName(headers, removeUnpartitionedCookie.name);
+                headers = pushCookie(headers, removeUnpartitionedCookie);
+            }
+        }
+        else if (autoChips) {
+            // add _CHIPS-${name} prefix cookie
+            const newCookieName = this.#formatChipsCookieName(name);
+            const newCookieOpts = {
+                ...opts,
+                partitioned: true,
+            };
+            const newPartitionedCookie = new Cookie(newCookieName, value, newCookieOpts);
+            // if user not set secure, reset secure to ctx.secure
+            if (opts.secure === undefined)
+                newPartitionedCookie.attrs.secure = this.secure;
+            headers = pushCookie(headers, newPartitionedCookie);
+            // signed
+            if (signed) {
+                newPartitionedCookie.value = value && this.keys.sign(newPartitionedCookie.toString());
+                newPartitionedCookie.name += '.sig';
+                headers = ignoreCookiesByName(headers, newPartitionedCookie.name);
+                headers = pushCookie(headers, newPartitionedCookie);
+            }
+        }
+        const cookie = new Cookie(name, value, opts);
+        // if user not set secure, reset secure to ctx.secure
+        if (opts.secure === undefined) {
+            cookie.attrs.secure = this.secure;
+        }
+        headers = pushCookie(headers, cookie);
+        // signed
+        if (signed) {
+            cookie.value = value && this.keys.sign(cookie.toString());
+            cookie.name += '.sig';
+            headers = pushCookie(headers, cookie);
+        }
+        this.ctx.set('set-cookie', headers);
+        return this;
+    }
+    #formatChipsCookieName(name) {
+        return `_CHIPS-${name}`;
+    }
+    #parseChromiumAndMajorVersion(userAgent) {
+        if (!this.#parseChromiumResult) {
+            this.#parseChromiumResult = parseChromiumAndMajorVersion(userAgent);
+        }
+        return this.#parseChromiumResult;
+    }
+    isSameSiteNoneCompatible(userAgent) {
+        // Chrome >= 80.0.0.0
+        const result = this.#parseChromiumAndMajorVersion(userAgent);
+        if (result.chromium) {
+            return result.majorVersion >= 80;
+        }
+        return isSameSiteNoneCompatible(userAgent);
+    }
+    isPartitionedCompatible(userAgent) {
+        // support: Chrome >= 114.0.0.0
+        // default enable: Chrome >= 118.0.0.0
+        // https://developers.google.com/privacy-sandbox/3pcd/chips
+        const result = this.#parseChromiumAndMajorVersion(userAgent);
+        if (result.chromium) {
+            return result.majorVersion >= 118;
+        }
+        return false;
+    }
+}
+// https://github.com/linsight/should-send-same-site-none/blob/master/index.js#L86
+function parseChromiumAndMajorVersion(userAgent) {
+    const m = /Chrom[^ /]{1,100}\/(\d{1,100}?)\./.exec(userAgent);
+    if (!m) {
+        return { chromium: false, majorVersion: 0 };
+    }
+    // Extract digits from first capturing group.
+    return { chromium: true, majorVersion: parseInt(m[1]) };
+}
+const _patternCache = new Map();
+function getPattern(name) {
+    const cache = _patternCache.get(name);
+    if (cache) {
+        return cache;
+    }
+    const reg = new RegExp('(?:^|;) *' +
+        name.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&') +
+        '=([^;]*)');
+    _patternCache.set(name, reg);
+    return reg;
+}
+function computeSigned(opts) {
+    // encrypt default to false, signed default to true.
+    // disable singed when encrypt is true.
+    if (opts.encrypt)
+        return false;
+    return opts.signed !== false;
+}
+function pushCookie(cookies, cookie) {
+    if (cookie.attrs.overwrite) {
+        cookies = ignoreCookiesByName(cookies, cookie.name);
+    }
+    cookies.push(cookie.toHeader());
+    return cookies;
+}
+function ignoreCookiesByName(cookies, name) {
+    const prefix = `${name}=`;
+    return cookies.filter(c => !c.startsWith(prefix));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cookies.js","sourceRoot":"","sources":["../../src/cookies.ts"],"names":[],"mappings":"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"}

package/dist/esm/error.d.ts

@@ -0,0 +1,3 @@
+export declare class CookieError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}

package/dist/esm/error.js

@@ -0,0 +1,7 @@
+export class CookieError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = this.constructor.name;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFdBQVksU0FBUSxLQUFLO0lBQ3BDLFlBQVksT0FBZSxFQUFFLE9BQXNCO1FBQ2pELEtBQUssQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDeEIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQztJQUNwQyxDQUFDO0NBQ0YifQ==

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cookies.js';
+export * from './cookie.js';
+export * from './error.js';
+export * from './keygrip.js';

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export * from './cookies.js';
+export * from './cookie.js';
+export * from './error.js';
+export * from './keygrip.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxjQUFjLENBQUMifQ==

package/dist/esm/keygrip.d.ts

@@ -0,0 +1,11 @@
+export declare class Keygrip {
+    #private;
+    constructor(keys: string[]);
+    encrypt(data: string, key?: string): Buffer;
+    decrypt(data: string | Buffer): {
+        value: Buffer;
+        index: number;
+    } | false;
+    sign(data: string | Buffer, key?: string): string;
+    verify(data: string, digest: string): number;
+}

package/dist/esm/keygrip.js

@@ -0,0 +1,113 @@
+import { debuglog } from 'node:util';
+import crypto from 'node:crypto';
+import assert from 'node:assert';
+const debug = debuglog('@eggjs/cookies:keygrip');
+const KEY_LEN = 32;
+const IV_SIZE = 16;
+const passwordCache = new Map();
+const replacer = {
+    '/': '_',
+    '+': '-',
+    '=': '',
+};
+function constantTimeCompare(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    return crypto.timingSafeEqual(a, b);
+}
+// patch from https://github.com/crypto-utils/keygrip
+export class Keygrip {
+    #keys;
+    #hash = 'sha256';
+    #cipher = 'aes-256-cbc';
+    constructor(keys) {
+        assert(Array.isArray(keys) && keys.length > 0, 'keys must be provided and should be an array');
+        this.#keys = keys;
+    }
+    // encrypt a message
+    encrypt(data, key) {
+        key = key || this.#keys[0];
+        const password = keyToPassword(key);
+        const cipher = crypto.createCipheriv(this.#cipher, password.key, password.iv);
+        return crypt(cipher, data);
+    }
+    // decrypt a single message
+    // returns false on bad decrypts
+    decrypt(data) {
+        // decrypt every key
+        const keys = this.#keys;
+        for (let i = 0; i < keys.length; i++) {
+            const value = this.#decryptByKey(data, keys[i]);
+            if (value !== false) {
+                return { value, index: i };
+            }
+        }
+        return false;
+    }
+    #decryptByKey(data, key) {
+        try {
+            const password = keyToPassword(key);
+            const cipher = crypto.createDecipheriv(this.#cipher, password.key, password.iv);
+            return crypt(cipher, data);
+        }
+        catch (err) {
+            debug('crypt error: %s', err);
+            return false;
+        }
+    }
+    sign(data, key) {
+        // default to the first key
+        key = key || this.#keys[0];
+        // url safe base64
+        return crypto
+            .createHmac(this.#hash, key)
+            .update(data)
+            .digest('base64')
+            .replace(/\/|\+|=/g, x => {
+            return replacer[x];
+        });
+    }
+    verify(data, digest) {
+        const keys = this.#keys;
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (constantTimeCompare(Buffer.from(digest), Buffer.from(this.sign(data, key)))) {
+                debug('data %s match key %s, index: %d', data, key, i);
+                return i;
+            }
+        }
+        return -1;
+    }
+}
+function crypt(cipher, data) {
+    const text = Buffer.isBuffer(data) ? cipher.update(data) : cipher.update(data, 'utf-8');
+    const pad = cipher.final();
+    return Buffer.concat([text, pad]);
+}
+function keyToPassword(key) {
+    if (passwordCache.has(key)) {
+        return passwordCache.get(key);
+    }
+    // Simulate EVP_BytesToKey.
+    // see https://github.com/nodejs/help/issues/1673#issuecomment-503222925
+    const bytes = Buffer.alloc(KEY_LEN + IV_SIZE);
+    let lastHash = null, nBytes = 0;
+    while (nBytes < bytes.length) {
+        const hash = crypto.createHash('md5');
+        if (lastHash)
+            hash.update(lastHash);
+        hash.update(key);
+        lastHash = hash.digest();
+        lastHash.copy(bytes, nBytes);
+        nBytes += lastHash.length;
+    }
+    // Use these for decryption.
+    const password = {
+        key: bytes.subarray(0, KEY_LEN),
+        iv: bytes.subarray(KEY_LEN, bytes.length),
+    };
+    passwordCache.set(key, password);
+    return password;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@eggjs/cookies",
+  "version": "3.0.0",
+  "engines": {
+    "node": ">= 18.19.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "cookies module for egg",
+  "dependencies": {
+    "should-send-same-site-none": "^2.0.5",
+    "utility": "^2.1.0"
+  },
+  "devDependencies": {
+    "beautify-benchmark": "^0.2.4",
+    "benchmark": "^2.1.4",
+    "cookies": "^0.7.1",
+    "keygrip": "^1.0.2",
+    "@arethetypeswrong/cli": "^0.15.3",
+    "@eggjs/tsconfig": "1",
+    "@types/node": "20",
+    "@types/mocha": "10",
+    "egg-bin": "6",
+    "eslint": "8",
+    "eslint-config-egg": "13",
+    "tshy": "1",
+    "tshy-after": "1",
+    "typescript": "5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/eggjs/egg-cookies.git"
+  },
+  "homepage": "https://github.com/eggjs/egg-cookies",
+  "author": "fengmk2 <fengmk2@gmail.com> (https://github.com/fengmk2)",
+  "license": "MIT",
+  "scripts": {
+    "lint": "eslint --cache src test --ext .ts",
+    "test": "npm run lint -- --fix && egg-bin test",
+    "ci": "npm run lint && egg-bin cov && npm run prepublishOnly && attw --pack",
+    "prepublishOnly": "tshy && tshy-after"
+  },
+  "type": "module",
+  "tshy": {
+    "exports": {
+      ".": "./src/index.ts",
+      "./package.json": "./package.json"
+    }
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "source": "./src/index.ts",
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "source": "./src/index.ts",
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "types": "./dist/commonjs/index.d.ts",
+  "main": "./dist/commonjs/index.js"
+}