haraka 0.0.33 → 3.3.0

package/test/plugins/queue/smtp_proxy.js

@@ -0,0 +1,138 @@
+'use strict'
+
+const assert = require('node:assert')
+const path = require('node:path')
+const { describe, it, beforeEach, afterEach, before } = require('node:test')
+
+const { makeConnection, makePlugin } = require('haraka-test-fixtures')
+
+const tls_socket = require('../../../tls_socket')
+
+before(() => {
+    require('haraka-constants').import(global)
+})
+
+describe('queue/smtp_proxy', () => {
+    let plugin, conn
+
+    beforeEach(() => {
+        plugin = makePlugin('queue/smtp_proxy', { register: false })
+        plugin.load_smtp_proxy_ini()
+        conn = makeConnection({ withTxn: true })
+    })
+
+    describe('hook_rset', () => {
+        it('calls next() when no smtp_client in notes', (t, done) => {
+            plugin.hook_rset((rc) => {
+                assert.equal(rc, undefined)
+                done()
+            }, conn)
+        })
+
+        it('releases smtp_client and calls next() when smtp_client exists', (t, done) => {
+            let released = false
+            conn.notes.smtp_client = {
+                release: () => {
+                    released = true
+                },
+            }
+            plugin.hook_rset(() => {
+                assert.equal(released, true)
+                assert.equal(conn.notes.smtp_client, undefined)
+                done()
+            }, conn)
+        })
+    })
+
+    describe('hook_quit', () => {
+        it('calls next() when no smtp_client in notes', (t, done) => {
+            plugin.hook_quit((rc) => {
+                assert.equal(rc, undefined)
+                done()
+            }, conn)
+        })
+
+        it('is the same function as hook_rset', () => {
+            assert.equal(plugin.hook_rset, plugin.hook_quit)
+        })
+    })
+
+    describe('hook_disconnect', () => {
+        it('calls next() when no smtp_client in notes', (t, done) => {
+            plugin.hook_disconnect((rc) => {
+                assert.equal(rc, undefined)
+                done()
+            }, conn)
+        })
+
+        it('releases and calls next when smtp_client exists', (t, done) => {
+            let released = false
+            let callNextCalled = false
+            conn.notes.smtp_client = {
+                release: () => {
+                    released = true
+                },
+                call_next: () => {
+                    callNextCalled = true
+                },
+            }
+            plugin.hook_disconnect(() => {
+                assert.equal(released, true)
+                assert.equal(callNextCalled, true)
+                assert.equal(conn.notes.smtp_client, undefined)
+                done()
+            }, conn)
+        })
+    })
+
+    describe('hook_queue', () => {
+        it('calls next() when transaction is missing', (t, done) => {
+            const connNoTxn = makeConnection()
+            plugin.hook_queue((rc) => {
+                assert.equal(rc, undefined)
+                done()
+            }, connNoTxn)
+        })
+
+        it('calls next() when smtp_client is not in notes', (t, done) => {
+            plugin.hook_queue((rc) => {
+                assert.equal(rc, undefined)
+                done()
+            }, conn)
+        })
+    })
+
+    describe('tls_options', () => {
+        let origTlsConfig, origTlsCfg
+
+        beforeEach(() => {
+            origTlsConfig = tls_socket.config
+            origTlsCfg = tls_socket.cfg
+            tls_socket.config = require('haraka-config').module_config(path.resolve('test'))
+            tls_socket.cfg = undefined
+            // re-derive with test/config in scope
+            plugin.load_smtp_proxy_ini()
+        })
+
+        afterEach(() => {
+            tls_socket.config = origTlsConfig
+            tls_socket.cfg = origTlsCfg
+        })
+
+        it('populates tls_options from tls.ini [main]', () => {
+            assert.ok(plugin.tls_options)
+            assert.equal(plugin.tls_options.rejectUnauthorized, false)
+            assert.equal(plugin.tls_options.minVersion, 'TLSv1')
+            assert.ok(plugin.tls_options.ciphers)
+            assert.ok(Array.isArray(plugin.tls_options.no_tls_hosts))
+            assert.ok(Array.isArray(plugin.tls_options.force_tls_hosts))
+        })
+
+        it('reload re-derives tls_options', () => {
+            const first = plugin.tls_options
+            plugin.load_smtp_proxy_ini()
+            assert.ok(plugin.tls_options)
+            assert.notEqual(plugin.tls_options, first)
+        })
+    })
+})

package/test/plugins/rcpt_to.host_list_base.js

@@ -0,0 +1,102 @@
+'use strict'
+const assert = require('node:assert/strict')
+const { describe, it, beforeEach } = require('node:test')
+
+const { Address } = require('../../address')
+const { assertResult, makeConnection, makePlugin } = require('haraka-test-fixtures')
+
+const _set_up = () => {
+    this.plugin = makePlugin('rcpt_to.host_list_base', { register: false })
+    this.plugin.cfg = {}
+    this.plugin.host_list = {}
+
+    this.connection = makeConnection({ withTxn: true })
+}
+
+describe('rcpt_to.host_list_base', () => {
+    describe('in_host_list', () => {
+        beforeEach(_set_up)
+
+        it('miss', () => {
+            assert.equal(false, this.plugin.in_host_list('test.com'))
+        })
+
+        it('hit', () => {
+            this.plugin.host_list['test.com'] = true
+            assert.equal(true, this.plugin.in_host_list('test.com'))
+        })
+    })
+
+    describe('in_host_regex', () => {
+        beforeEach(_set_up)
+
+        const setRegex = (patterns) => {
+            this.plugin.host_list_regex = patterns
+            this.plugin.hl_re = new RegExp(`^(?:${patterns.join('|')})$`, 'i')
+        }
+
+        it('returns false when hl_re is not set', () => {
+            assert.equal(this.plugin.in_host_regex('test.com'), false)
+        })
+
+        const cases = [
+            { desc: 'miss', patterns: ['miss.com'], domain: 'test.com', expected: false },
+            { desc: 'exact hit', patterns: ['test.com'], domain: 'test.com', expected: true },
+            { desc: 're hit', patterns: ['.*est.com'], domain: 'test.com', expected: true },
+        ]
+        for (const { desc, patterns, domain, expected } of cases) {
+            it(desc, () => {
+                setRegex(patterns)
+                assert.equal(this.plugin.in_host_regex(domain), expected)
+            })
+        }
+    })
+
+    describe('hook_mail', () => {
+        beforeEach(_set_up)
+
+        const setRegex = (patterns) => {
+            this.plugin.host_list_regex = patterns
+            this.plugin.hl_re = new RegExp(`^(?:${patterns.join('|')})$`, 'i')
+        }
+
+        const callMailHook = (addr) =>
+            new Promise((resolve) => {
+                this.plugin.hook_mail((rc, msg) => resolve({ rc, msg }), this.connection, [new Address(addr)])
+            })
+
+        it('null sender always passes when relaying', async () => {
+            this.connection.relaying = true
+            const { rc, msg } = await callMailHook('<>')
+            assert.equal(rc, undefined)
+            assert.equal(msg, undefined)
+        })
+
+        it('miss: records mail_from!local in results', async () => {
+            this.plugin.host_list = { 'miss.com': true }
+            const { rc, msg } = await callMailHook('<user@example.com>')
+            assert.equal(rc, undefined)
+            assert.equal(msg, undefined)
+            assertResult(this.connection.transaction, 'rcpt_to.host_list_base', 'msg', /^mail_from!local$/)
+        })
+
+        for (const [desc, setup] of [
+            [
+                'hit',
+                () => {
+                    this.plugin.host_list = { 'example.com': true }
+                },
+            ],
+            ['hit, regex, exact', () => setRegex(['example.com'])],
+            ['hit, regex, pattern', () => setRegex(['.*mple.com'])],
+        ]) {
+            it(desc, async () => {
+                setup()
+                const { rc, msg } = await callMailHook('<user@example.com>')
+                assert.equal(rc, undefined)
+                assert.equal(msg, undefined)
+                assertResult(this.connection.transaction, 'rcpt_to.host_list_base', 'pass', /^mail_from$/)
+            })
+        }
+    })
+})

package/test/plugins/rcpt_to.in_host_list.js

@@ -0,0 +1,186 @@
+'use strict'
+const assert = require('node:assert/strict')
+const { describe, it, beforeEach } = require('node:test')
+
+const { Address } = require('../../address')
+const fixtures = require('haraka-test-fixtures')
+const { assertResult, makeConnection, makePlugin } = fixtures
+require('haraka-constants').import(global)
+
+const _set_up = () => {
+    this.plugin = makePlugin('rcpt_to.in_host_list', { register: false })
+    this.plugin.inherits('rcpt_to.host_list_base')
+    this.plugin.cfg = {}
+    this.plugin.host_list = {}
+
+    this.connection = makeConnection({ withTxn: true })
+}
+
+describe('in_host_list', () => {
+    beforeEach(_set_up)
+
+    it('miss', () => {
+        assert.equal(this.plugin.in_host_list('test.com'), false)
+    })
+
+    it('hit', () => {
+        this.plugin.host_list['test.com'] = true
+        assert.equal(this.plugin.in_host_list('test.com'), true)
+    })
+
+    describe('in_host_regex', () => {
+        beforeEach(_set_up)
+
+        const setRegex = (patterns) => {
+            this.plugin.host_list_regex = patterns
+            this.plugin.hl_re = new RegExp(`^(?:${patterns.join('|')})$`, 'i')
+        }
+
+        it('returns false when hl_re is not set', () => {
+            assert.equal(this.plugin.in_host_regex('test.com'), false)
+        })
+
+        const cases = [
+            { desc: 'miss', patterns: ['miss.com'], domain: 'test.com', expected: false },
+            { desc: 'exact hit', patterns: ['test.com'], domain: 'test.com', expected: true },
+            { desc: 're hit', patterns: ['.*est.com'], domain: 'test.com', expected: true },
+        ]
+        for (const { desc, patterns, domain, expected } of cases) {
+            it(desc, () => {
+                setRegex(patterns)
+                assert.equal(this.plugin.in_host_regex(domain), expected)
+            })
+        }
+    })
+
+    describe('hook_mail', () => {
+        beforeEach(_set_up)
+
+        const setRegex = (patterns) => {
+            this.plugin.host_list_regex = patterns
+            this.plugin.hl_re = new RegExp(`^(?:${patterns.join('|')})$`, 'i')
+        }
+
+        const callMailHook = (addr) =>
+            new Promise((resolve) => {
+                this.plugin.hook_mail((rc, msg) => resolve({ rc, msg }), this.connection, [new Address(addr)])
+            })
+
+        it('null sender always passes when relaying', async () => {
+            this.connection.relaying = true
+            const { rc, msg } = await callMailHook('<>')
+            assert.equal(rc, undefined)
+            assert.equal(msg, undefined)
+        })
+
+        it('miss: records mail_from!local in results', async () => {
+            this.plugin.host_list = { 'miss.com': true }
+            const { rc, msg } = await callMailHook('<user@example.com>')
+            assert.equal(rc, undefined)
+            assert.equal(msg, undefined)
+            assertResult(this.connection.transaction, 'rcpt_to.in_host_list', 'msg', /^mail_from!local$/)
+        })
+
+        for (const [desc, setup] of [
+            [
+                'hit',
+                () => {
+                    this.plugin.host_list = { 'example.com': true }
+                },
+            ],
+            ['hit, regex, exact', () => setRegex(['example.com'])],
+            ['hit, regex, pattern', () => setRegex(['.*mple.com'])],
+        ]) {
+            it(desc, async () => {
+                setup()
+                const { rc, msg } = await callMailHook('<user@example.com>')
+                assert.equal(rc, undefined)
+                assert.equal(msg, undefined)
+                assertResult(this.connection.transaction, 'rcpt_to.in_host_list', 'pass', /^mail_from$/)
+            })
+        }
+    })
+
+    describe('hook_rcpt', () => {
+        beforeEach(_set_up)
+
+        const setRegex = (patterns) => {
+            this.plugin.host_list_regex = patterns
+            this.plugin.hl_re = new RegExp(`^(?:${patterns.join('|')})$`, 'i')
+        }
+
+        const callRcptHook = (addr) =>
+            new Promise((resolve) => {
+                this.plugin.hook_rcpt((rc, msg) => resolve({ rc, msg }), this.connection, [new Address(addr)])
+            })
+
+        it('missing txn: does not call next (returns early)', () => {
+            // When transaction is missing the plugin returns without calling next()
+            delete this.connection.transaction
+            let nextCalled = false
+            this.plugin.hook_rcpt(
+                () => {
+                    nextCalled = true
+                },
+                this.connection,
+                [new Address('test@test.com')],
+            )
+            assert.equal(nextCalled, false)
+        })
+
+        const cases = [
+            {
+                desc: 'hit list',
+                setup: () => {
+                    this.plugin.host_list = { 'test.com': true }
+                },
+                addr: 'test@test.com',
+                expectedRC: OK,
+            },
+            {
+                desc: 'miss list',
+                setup: () => {
+                    this.plugin.host_list = { 'miss.com': true }
+                },
+                addr: 'test@test.com',
+                expectedRC: undefined,
+            },
+            {
+                desc: 'hit regex, exact',
+                setup: () => setRegex(['test.com']),
+                addr: 'test@test.com',
+                expectedRC: OK,
+            },
+            {
+                desc: 'hit regex, pattern',
+                setup: () => setRegex(['.est.com']),
+                addr: 'test@test.com',
+                expectedRC: OK,
+            },
+            {
+                desc: 'miss regex, pattern',
+                setup: () => setRegex(['a.est.com']),
+                addr: 'test@test.com',
+                expectedRC: undefined,
+            },
+            {
+                desc: 'rcpt miss, relaying to local sender',
+                setup: () => {
+                    this.connection.relaying = true
+                    this.connection.transaction.notes = { local_sender: true }
+                },
+                addr: 'test@test.com',
+                expectedRC: OK,
+            },
+        ]
+
+        for (const { desc, setup, addr, expectedRC } of cases) {
+            it(desc, async () => {
+                setup()
+                const { rc, msg } = await callRcptHook(addr)
+                assert.equal(rc, expectedRC)
+                assert.equal(msg, undefined)
+            })
+        }
+    })
+})

package/test/plugins/record_envelope_addresses.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const assert = require('node:assert')
+const { describe, it, beforeEach } = require('node:test')
+
+const { callMail, callRcpt, makeConnection, makePlugin } = require('haraka-test-fixtures')
+
+const _set_up = () => {
+    this.plugin = makePlugin('record_envelope_addresses')
+    this.connection = makeConnection({ withTxn: true })
+}
+
+describe('record_envelope_addresses', () => {
+    beforeEach(_set_up)
+
+    describe('hook_mail', () => {
+        it('adds X-Envelope-From header from MAIL FROM address', (t, done) => {
+            callMail(this.plugin, this.connection, 'sender@example.com').then(() => {
+                const vals = this.connection.transaction.header.get_all('X-Envelope-From')
+                assert.equal(vals.length, 1, 'header was added')
+                assert.equal(vals[0], 'sender@example.com')
+                done()
+            })
+        })
+
+        it('does not throw when connection has no transaction', (t, done) => {
+            this.connection.transaction = null
+            callMail(this.plugin, this.connection, 'sender@example.com').then(() => {
+                assert.ok(true, 'next was called without error')
+                done()
+            })
+        })
+    })
+
+    describe('hook_rcpt', () => {
+        it('adds X-Envelope-To header from RCPT TO address', (t, done) => {
+            callRcpt(this.plugin, this.connection, 'rcpt@example.com').then(() => {
+                const vals = this.connection.transaction.header.get_all('X-Envelope-To')
+                assert.equal(vals.length, 1, 'header was added')
+                assert.equal(vals[0], 'rcpt@example.com')
+                done()
+            })
+        })
+
+        it('adds X-Envelope-To header for each recipient', (t, done) => {
+            Promise.all([
+                callRcpt(this.plugin, this.connection, 'one@example.com'),
+                callRcpt(this.plugin, this.connection, 'two@example.com'),
+            ]).then(() => {
+                const vals = this.connection.transaction.header.get_all('X-Envelope-To')
+                assert.equal(vals.length, 2, 'two headers added')
+                assert.equal(vals[0], 'one@example.com')
+                assert.equal(vals[1], 'two@example.com')
+                done()
+            })
+        })
+
+        it('does not throw when connection has no transaction', (t, done) => {
+            this.connection.transaction = null
+            callRcpt(this.plugin, this.connection, 'rcpt@example.com').then(() => {
+                assert.ok(true, 'next was called without error')
+                done()
+            })
+        })
+    })
+})

package/test/plugins/reseed_rng.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { describe, it } = require('node:test')
+
+const { makePlugin } = require('haraka-test-fixtures')
+
+describe('reseed_rng', () => {
+    describe('hook_init_child', () => {
+        it('calls Math.seedrandom with a hex string and calls next', (t, done) => {
+            const plugin = makePlugin('reseed_rng', { register: false })
+            let called = false
+            let calledArg
+            Math.seedrandom = (arg) => {
+                called = true
+                calledArg = arg
+            }
+            plugin.hook_init_child((rc) => {
+                delete Math.seedrandom
+                assert.equal(rc, undefined)
+                assert.ok(called, 'Math.seedrandom should have been called')
+                assert.equal(typeof calledArg, 'string')
+                assert.ok(calledArg.length > 0)
+                done()
+            })
+        })
+
+        it('throws when Math.seedrandom is not defined', () => {
+            const plugin = makePlugin('reseed_rng', { register: false })
+            delete Math.seedrandom
+            assert.throws(() => plugin.hook_init_child(() => {}), /Math\.seedrandom is not a function/)
+        })
+    })
+})