imapkit 4.0.2 → 4.1.0

package/dist/cjs/plugins/appendlimit.d.ts

@@ -0,0 +1,16 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds APPENDLIMIT [RFC7889] capability
+ * @help Server option "appendLimit" sets the limit in octets for all
+ * @help mailboxes, a mailbox in storage can set its own "appendLimit"
+ * @help (null for no limit)
+ *
+ * APPENDLIMIT: https://www.rfc-editor.org/rfc/rfc7889
+ *
+ * The server option "appendLimit" (octets) sets a limit for all mailboxes, advertised as
+ * APPENDLIMIT=<n>. A mailbox in the storage can set its own "appendLimit" (a number, or null
+ * for no limit), then the capability is a plain APPENDLIMIT and clients read the limits with
+ * STATUS (APPENDLIMIT). A larger APPEND or REPLACE fails with NO [TOOBIG], a synchronizing
+ * literal is refused before it is sent.
+ */
+export default function appendlimitPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/appendlimit.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = appendlimitPlugin;
+const append_js_1 = require("../commands/append.js");
+/**
+ * @help Adds APPENDLIMIT [RFC7889] capability
+ * @help Server option "appendLimit" sets the limit in octets for all
+ * @help mailboxes, a mailbox in storage can set its own "appendLimit"
+ * @help (null for no limit)
+ *
+ * APPENDLIMIT: https://www.rfc-editor.org/rfc/rfc7889
+ *
+ * The server option "appendLimit" (octets) sets a limit for all mailboxes, advertised as
+ * APPENDLIMIT=<n>. A mailbox in the storage can set its own "appendLimit" (a number, or null
+ * for no limit), then the capability is a plain APPENDLIMIT and clients read the limits with
+ * STATUS (APPENDLIMIT). A larger APPEND or REPLACE fails with NO [TOOBIG], a synchronizing
+ * literal is refused before it is sent.
+ */
+function appendlimitPlugin(server) {
+    const serverLimit = 'appendLimit' in server.options ? server.options.appendLimit : null;
+    if (serverLimit !== null && !isValidLimit(serverLimit)) {
+        throw new TypeError('Invalid appendLimit option, expecting a non-negative integer');
+    }
+    const hasOwnLimit = (mailbox) => Object.hasOwn(mailbox, 'appendLimit');
+    const hasMailboxLimits = () => Object.values(server.folderCache).some(hasOwnLimit);
+    /**
+     * @param {Object} mailbox Mailbox object
+     * @return {Number|null} limit in octets, null if there is no limit
+     */
+    const getLimit = (mailbox) => {
+        if (!hasOwnLimit(mailbox)) {
+            return serverLimit;
+        }
+        return isValidLimit(mailbox.appendLimit) ? mailbox.appendLimit : null;
+    };
+    // RFC 7889 section 5: an APPENDLIMIT of 0 means that nothing can be appended
+    const isTooBig = (mailbox, size) => {
+        const limit = getLimit(mailbox);
+        return limit !== null && (size > limit || limit === 0);
+    };
+    // RFC 7889 section 2: APPENDLIMIT=<n> for the same limit in every mailbox, otherwise a plain
+    // APPENDLIMIT and the limits come from STATUS
+    if (serverLimit !== null) {
+        server.registerCapability('APPENDLIMIT=' + serverLimit, () => !hasMailboxLimits());
+    }
+    server.registerCapability('APPENDLIMIT', () => serverLimit === null || hasMailboxLimits());
+    // RFC 7889 section 4: a message over the limit is refused with TOOBIG
+    server.appendChecks.push((connection, mailbox, messages, options) => {
+        // COPY and MOVE are not uploads (RFC 7889 section 1)
+        if (!options.command) {
+            return false;
+        }
+        if (messages.some(message => isTooBig(mailbox, message.raw.length))) {
+            return { code: 'TOOBIG', text: 'Message exceeds the APPENDLIMIT of the mailbox' };
+        }
+        return false;
+    });
+    // Refuse the literal of a message that is too large before the client sends it, by not
+    // sending a continuation request (RFC 3502 section 6.3.11 example A005)
+    server.literalFilters.push((connection, command, line, literalSize) => {
+        const path = (0, append_js_1.getPendingTarget)(connection, command, line);
+        const mailbox = path !== false && server.getMailbox(path);
+        if (mailbox && isTooBig(mailbox, literalSize)) {
+            return { command: 'NO', code: 'TOOBIG', text: 'Message exceeds the APPENDLIMIT of the mailbox' };
+        }
+        return false;
+    });
+    // RFC 7889 section 3.1: status-att-val =/ "APPENDLIMIT" SP (number / nil)
+    server.allowedStatus.push('APPENDLIMIT');
+    // also used by the STATUS return option of LIST-STATUS (RFC 7889 section 3.2)
+    server.statusHandlers.APPENDLIMIT = (connection, mailbox) => getLimit(mailbox);
+}
+function isValidLimit(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/plugins/auth-plain.d.ts

@@ -0,0 +1,2 @@
+import type { IMAPServer } from '../types.js';
+export default function authPlainPlugin(server: IMAPServer): void;

package/dist/cjs/plugins/auth-plain.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = authPlainPlugin;
+/**
+ * @help Adds AUTH=PLAIN capability
+ * @help Supports SASL-IR [RFC4959] as well
+ */
+const utf8 = new TextDecoder('utf-8', { fatal: true });
+function authPlainPlugin(server) {
+    // Register AUTH=PLAIN capability for non authenticated state
+    server.registerCapability('AUTH=PLAIN', (connection) => {
+        return connection.state === 'Not Authenticated';
+    });
+    // Validates a base64 encoded "authzid NUL authcid NUL passwd" message (RFC 4616) and logs the user in
+    const authenticate = (connection, parsed, data, input) => {
+        const decoded = connection.decodeSaslResponse(input);
+        if (!decoded) {
+            return connection.sendStatus(parsed, data, 'BAD', 'Invalid base64 in SASL response', false, 'AUTHENTICATE PLAIN FAILED');
+        }
+        // RFC 4616 section 2: the message is UTF-8, user names are unicode strings like the keys of `users`
+        let message;
+        try {
+            message = utf8.decode(decoded);
+        }
+        catch {
+            return connection.sendStatus(parsed, data, 'BAD', 'Invalid UTF-8 in SASL PLAIN message', false, 'AUTHENTICATE PLAIN FAILED');
+        }
+        const parts = message.split('\x00');
+        const authzid = parts[0] || '';
+        const username = parts[1] || '';
+        const password = parts[2] || '';
+        const user = connection.server.getUser(username);
+        if (parts.length !== 3 || !user || user.password !== password) {
+            // RFC 5530 section 3: unknown user or bad password
+            return connection.sendStatus(parsed, data, 'NO', 'Login failed: authentication failure', 'AUTHENTICATIONFAILED', 'AUTHENTICATE PLAIN FAILED');
+        }
+        if (authzid && authzid !== username) {
+            // Acting as another user is not supported, authzid must be empty or the same as authcid. The credentials
+            // were fine, so this is AUTHORIZATIONFAILED (RFC 5530 section 3, RFC 9051 section 7.1)
+            return connection.sendStatus(parsed, data, 'NO', 'Can not act as ' + authzid, 'AUTHORIZATIONFAILED', 'AUTHENTICATE PLAIN FAILED');
+        }
+        connection.state = 'Authenticated';
+        connection.username = username;
+        connection.sendStatus(parsed, data, 'OK', 'User logged in', false, 'AUTHENTICATE PLAIN SUCCESS');
+    };
+    server.setCommandHandler('AUTHENTICATE PLAIN', (connection, parsed, data, callback) => {
+        // If this is the old style api, send + and wait for password
+        if (!parsed.attributes) {
+            // Temporarily redirect client input to this function
+            connection.inputHandler = function (str) {
+                // Stop listening to any other user input
+                connection.inputHandler = false;
+                if (str === '*') {
+                    // Client cancelled the exchange (RFC 3501 section 6.2.2)
+                    return connection.sendStatus(parsed, data, 'BAD', 'Authentication cancelled', false, 'AUTHENTICATE PLAIN FAILED');
+                }
+                authenticate(connection, parsed, data, str);
+            };
+            // Send an empty continuation request to the client
+            connection.write('+ \r\n');
+        }
+        else if (parsed.attributes.length === 1 &&
+            // second argument must be Base64 string as ATOM
+            parsed.attributes[0].type === 'ATOM') {
+            if (!server.capabilities['SASL-IR'] || !server.capabilities['SASL-IR'](connection)) {
+                connection.sendStatus(parsed, data, 'BAD', 'SASL-IR must be enabled to send Initial Response with the request', false, 'AUTHENTICATE PLAIN FAILED');
+                return callback();
+            }
+            authenticate(connection, parsed, data, parsed.attributes[0].value);
+        }
+        else {
+            // Not correct AUTH=PLAIN
+            connection.sendStatus(parsed, data, 'BAD', 'Invalid attributes for AUTHENTICATE PLAIN', false, 'AUTHENTICATE PLAIN FAILED');
+        }
+        return callback();
+    });
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/plugins/binary.d.ts

@@ -0,0 +1,30 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * Decodes base64 data. RFC 2045 section 6.8: characters outside the base64 alphabet are ignored, and
+ * "=" marks the end of the data
+ *
+ * @param {String} str Encoded data
+ * @return {String} Decoded octets as a binary string
+ */
+declare function decodeBase64(str: string): string;
+/**
+ * Decodes quoted-printable data (RFC 2045 section 6.7). Trailing white space of a line is removed
+ * (rule 3), a line that ends with "=" continues on the next line (rule 5), and an "=" that is not
+ * followed by two hex digits is kept as it is, as the RFC suggests for robust implementations
+ *
+ * @param {String} str Encoded data with CRLF line breaks
+ * @return {String} Decoded octets as a binary string
+ */
+declare function decodeQuotedPrintable(str: string): string;
+/**
+ * Base64 encodes the binary parts of a message that was appended as a literal8, as the IMAP4rev1
+ * part of the protocol can not carry them (RFC 3516 sections 4.4 and 6): parts with the binary
+ * encoding, and parts with an identity encoding that contain NUL octets anyway. Any other NUL octet
+ * (in a header, or in a part with another encoding) can not be stored.
+ *
+ * @param {String} raw Message as a binary string
+ * @return {String} Message to store
+ */
+declare function storeBinaryMessage(raw: string): string;
+export default function binaryPlugin(server: IMAPServer): void;
+export { decodeBase64, decodeQuotedPrintable, storeBinaryMessage };

package/dist/cjs/plugins/binary.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = binaryPlugin;
+exports.decodeBase64 = decodeBase64;
+exports.decodeQuotedPrintable = decodeQuotedPrintable;
+exports.storeBinaryMessage = storeBinaryMessage;
+const mimeparser_js_1 = require("../mimeparser.js");
+const fetch_js_1 = require("../commands/handlers/fetch.js");
+const append_js_1 = require("../commands/append.js");
+/**
+ * @help Adds BINARY [RFC3516] capability
+ *
+ * BINARY: https://www.rfc-editor.org/rfc/rfc3516
+ *
+ * Additional FETCH items:
+ * - BINARY[<part>]<<partial>>, BINARY.PEEK[<part>]<<partial>> and BINARY.SIZE[<part>]
+ *
+ * APPEND (and REPLACE) accept messages as a literal8 (~{n}), binary parts are stored base64 encoded
+ */
+// RFC 3516 section 7: section-binary = "[" [section-part] "]", section-part = nz-number *("." nz-number)
+const SECTION_PART = /^[1-9]\d*(?:\.[1-9]\d*)*$/;
+// decoded leaf parts, the tree of a message is replaced when its source changes
+const decodedCache = new WeakMap();
+/**
+ * Creates an error that fails a command with NO [UNKNOWN-CTE] (RFC 3516 sections 4.3 and 4.4)
+ *
+ * @param {String} message Human readable text
+ * @return {Error}
+ */
+function unknownCte(message) {
+    const err = new Error(message);
+    err.imapResponse = 'NO';
+    err.code = 'UNKNOWN-CTE';
+    return err;
+}
+/**
+ * Returns the media type of a tree node, e.g. "text/plain"
+ */
+function mediaType(node) {
+    const contentType = node.parsedHeader['content-type'];
+    return ((contentType && contentType.value) || '').toLowerCase();
+}
+/**
+ * Returns the lower case content transfer encoding of a node, 7bit if not set (RFC 2045 section 6.1)
+ */
+function transferEncoding(node) {
+    return (node.parsedHeader['content-transfer-encoding'] || '7bit').toString().trim().toLowerCase();
+}
+/**
+ * RFC 9051 section 6.4.5: BINARY applies to leaf body parts only, not to multipart/*, message/rfc822
+ * or message/global parts. IMAP4rev1 describes message/global as a basic part (RFC 3501 body-type-basic)
+ *
+ * @param {Object} node Tree node
+ * @param {Boolean} global message/global is not a leaf, see IMAPConnection#messageGlobal
+ */
+function isLeaf(node, global) {
+    const type = mediaType(node);
+    return !node.boundary && !/^multipart\//.test(type) && type !== 'message/rfc822' && (!global || type !== 'message/global');
+}
+/**
+ * Decodes base64 data. RFC 2045 section 6.8: characters outside the base64 alphabet are ignored, and
+ * "=" marks the end of the data
+ *
+ * @param {String} str Encoded data
+ * @return {String} Decoded octets as a binary string
+ */
+function decodeBase64(str) {
+    let data = str.replace(/[^A-Za-z0-9+/=]/g, '').split('=')[0];
+    if (data.length % 4 === 1) {
+        // a single leftover character does not hold a whole octet
+        data = data.slice(0, -1);
+    }
+    return Buffer.from(data, 'base64').toString('binary');
+}
+/**
+ * Decodes quoted-printable data (RFC 2045 section 6.7). Trailing white space of a line is removed
+ * (rule 3), a line that ends with "=" continues on the next line (rule 5), and an "=" that is not
+ * followed by two hex digits is kept as it is, as the RFC suggests for robust implementations
+ *
+ * @param {String} str Encoded data with CRLF line breaks
+ * @return {String} Decoded octets as a binary string
+ */
+function decodeQuotedPrintable(str) {
+    return str
+        .replace(/[ \t]+(?=\r\n|$)/g, '')
+        .replace(/=(?:\r\n|$)/g, '')
+        .replace(/=([0-9A-Fa-f]{2})/g, (match, hex) => String.fromCharCode(parseInt(hex, 16)));
+}
+/**
+ * Returns the content of a BINARY section with the content transfer encoding removed
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} message Message object
+ * @param {Object} query Parsed fetch item
+ * @return {String} Decoded section as a binary string
+ */
+function getDecodedSection(connection, message, query) {
+    const key = query.value.toUpperCase();
+    const section = query.section;
+    if (!section) {
+        throw new Error(key + ' requires a section');
+    }
+    if (!section.length) {
+        // the grammar allows BINARY[], but the whole message is not a leaf body part
+        throw new Error(key + '[] is not allowed, BINARY applies to leaf body parts only (RFC 9051 section 6.4.5)');
+    }
+    if (section.length !== 1 || section[0].type !== 'ATOM' || !SECTION_PART.test(section[0].value)) {
+        throw new Error('Invalid ' + key + ' section, expecting a part number (RFC 3516 section 7)');
+    }
+    const node = (0, mimeparser_js_1.resolveNode)((0, mimeparser_js_1.getMessageData)(message).tree, section[0].value, connection.messageGlobal);
+    if (!node) {
+        // like BODY[<section>], a part that does not exist is empty
+        return '';
+    }
+    if (!isLeaf(node, connection.messageGlobal)) {
+        throw new Error(key + '[' + section[0].value + '] is not a leaf body part (RFC 9051 section 6.4.5)');
+    }
+    if (!decodedCache.has(node)) {
+        decodedCache.set(node, decodeNode(node));
+    }
+    return decodedCache.get(node);
+}
+/**
+ * Removes the content transfer encoding of a leaf part
+ *
+ * @param {Object} node Tree node
+ * @return {String} Decoded body as a binary string
+ */
+function decodeNode(node) {
+    const body = (0, mimeparser_js_1.render)(node, true);
+    const encoding = transferEncoding(node);
+    let decoded;
+    if (mimeparser_js_1.IDENTITY_ENCODINGS.includes(encoding)) {
+        decoded = body;
+    }
+    else if (encoding === 'base64') {
+        decoded = decodeBase64(body);
+    }
+    else if (encoding === 'quoted-printable') {
+        decoded = decodeQuotedPrintable(body);
+    }
+    else {
+        throw unknownCte('Unknown Content-Transfer-Encoding ' + JSON.stringify(encoding).replace(/[^\x20-\x7e]/g, '?'));
+    }
+    // RFC 3516 section 6: textual sections are sent with CRLF line breaks
+    return /^text\//.test(mediaType(node)) ? (0, mimeparser_js_1.normalizeLineBreaks)(decoded) : decoded;
+}
+/**
+ * BINARY[<section>]<<partial>> (RFC 3516 section 4.2)
+ */
+function fetchBinary(connection, message, query) {
+    // RFC 3516 section 4.2: the range applies to the decoded data
+    const value = (0, fetch_js_1.applyPartial)(getDecodedSection(connection, message, query), query.partial);
+    // RFC 3516 section 4.3: data without NUL is sent as a string, a literal8 only when it is needed
+    return {
+        type: value.indexOf('\x00') >= 0 ? 'LITERAL8' : 'LITERAL',
+        value
+    };
+}
+// BINARY sets \Seen like BODY[<section>] does
+fetchBinary.setsSeen = true;
+/**
+ * BINARY.SIZE[<section>] (RFC 3516 section 4.2), the size of the decoded section
+ */
+function fetchBinarySize(connection, message, query) {
+    if (query.partial) {
+        // RFC 3516 section 7: "BINARY.SIZE" section-binary, without a partial
+        throw new Error('BINARY.SIZE does not take a partial range');
+    }
+    return getDecodedSection(connection, message, query).length;
+}
+/**
+ * Base64 encodes the binary parts of a message that was appended as a literal8, as the IMAP4rev1
+ * part of the protocol can not carry them (RFC 3516 sections 4.4 and 6): parts with the binary
+ * encoding, and parts with an identity encoding that contain NUL octets anyway. Any other NUL octet
+ * (in a header, or in a part with another encoding) can not be stored.
+ *
+ * @param {String} raw Message as a binary string
+ * @return {String} Message to store
+ */
+function storeBinaryMessage(raw) {
+    const tree = (0, mimeparser_js_1.parseTree)(raw);
+    // returns true if the node or anything in it was converted
+    const convert = (node) => {
+        if (node.childNodes) {
+            // every part is converted, so no short circuit
+            return node.childNodes.map(convert).includes(true);
+        }
+        const message = (0, mimeparser_js_1.embeddedMessage)(node, true);
+        if (message) {
+            // RFC 2046 section 5.2.1: a message/rfc822 (or message/global) part keeps its identity encoding, its parts are converted
+            if (!convert(message)) {
+                return false;
+            }
+            node.body = (0, mimeparser_js_1.render)(message);
+            return true;
+        }
+        const encoding = transferEncoding(node);
+        if (!isLeaf(node, true) || !node.body || !(encoding === 'binary' || (mimeparser_js_1.IDENTITY_ENCODINGS.includes(encoding) && node.body.indexOf('\x00') >= 0))) {
+            return false;
+        }
+        // RFC 2045 section 6.8: encoded lines are at most 76 characters long
+        node.body = Buffer.from(node.body, 'binary')
+            .toString('base64')
+            .match(/.{1,76}/g)
+            .join('\r\n');
+        node.header = node.header.filter((line) => !/^content-transfer-encoding\s*:/i.test(line)).concat('Content-Transfer-Encoding: base64');
+        return true;
+    };
+    const result = convert(tree) ? (0, mimeparser_js_1.render)(tree) : raw;
+    if (result.indexOf('\x00') >= 0) {
+        throw unknownCte('NUL octets are only allowed in the body of a part with the binary, 7bit or 8bit encoding');
+    }
+    return result;
+}
+function binaryPlugin(server) {
+    server.registerCapability('BINARY');
+    // RFC 3516 section 7: literal8 and the BINARY fetch items with a section and a partial range
+    server.parserOptions.literal8 = true;
+    server.parserOptions.allowSection.push('BINARY', 'BINARY.PEEK', 'BINARY.SIZE');
+    server.fetchHandlers.BINARY = fetchBinary;
+    // the same without setting \Seen
+    server.fetchHandlers['BINARY.PEEK'] = (connection, message, query) => fetchBinary(connection, message, query);
+    server.fetchHandlers['BINARY.SIZE'] = fetchBinarySize;
+    // RFC 3516 section 4.4: APPEND (and REPLACE, MULTIAPPEND) take a message as a literal8, the commands
+    // allow it with the literal8: 'BINARY' option
+    server.appendLiteral8 = (raw) => {
+        try {
+            return storeBinaryMessage(raw);
+        }
+        catch (err) {
+            throw (0, append_js_1.appendError)(err.message, err.code);
+        }
+    };
+}
+{
+    const defaultExport = exports.default;
+    if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {
+        for (const key of Object.keys(exports)) {
+            if (key !== 'default' && !(key in defaultExport)) {
+                defaultExport[key] = exports[key];
+            }
+        }
+        Object.defineProperty(defaultExport, 'default', { value: defaultExport, enumerable: false, writable: true, configurable: true });
+        module.exports = defaultExport;
+    }
+}

package/dist/cjs/plugins/catenate.d.ts

@@ -0,0 +1,14 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds CATENATE [RFC4469] and URL-PARTIAL [RFC5550] capabilities
+ * @help Only absolute-path URLs are accepted, eg. "/INBOX/;UID=1/;SECTION=1"
+ *
+ * CATENATE: https://www.rfc-editor.org/rfc/rfc4469
+ *
+ * APPEND (and REPLACE) can build a message from literals and IMAP URLs of messages or
+ * message parts on this server. Only absolute-path URLs are accepted, for example
+ * "/INBOX;UIDVALIDITY=1/;UID=2/;SECTION=1.MIME/;PARTIAL=0.100" (RFC 5092). Other URLs,
+ * and URLs that do not resolve, fail with NO [BADURL]. A message larger than the
+ * literal size limit fails with NO [TOOBIG].
+ */
+export default function catenatePlugin(server: IMAPServer): void;