serve.zone/dcrouter
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
Philipp Kunz
2025-05-24 14:39:48 +00:00
parent dc5c0b2584
commit 6e19e30f87
80 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

382
test/suite/smtpserver_rfc-compliance/test.rfc-01.rfc5321-compliance.ts Normal file
View File

@ -0,0 +1,382 @@
import { tap, expect } from '@git.zone/tstest/tapbundle';
import * as plugins from '../../../ts/plugins.js';
import * as net from 'net';
import { startTestServer, stopTestServer } from '../../helpers/server.loader.js'
import type { ITestServer } from '../../helpers/server.loader.js';
const TEST_PORT = 2525;
let testServer: ITestServer;
// Helper function to wait for SMTP response
const waitForResponse = (socket: net.Socket, expectedCode?: string, timeout = 5000): Promise<string> => {
return new Promise((resolve, reject) => {
let buffer = '';
const timer = setTimeout(() => {
socket.removeListener('data', handler);
reject(new Error(`Timeout waiting for ${expectedCode || 'any'} response`));
}, timeout);
const handler = (data: Buffer) => {
buffer += data.toString();
const lines = buffer.split('\r\n');
// Check if we have a complete response
for (const line of lines) {
if (expectedCode) {
if (line.startsWith(expectedCode + ' ')) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
} else {
// Any complete response line
if (line.match(/^\d{3} /)) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
}
}
};
socket.on('data', handler);
});
};
tap.test('setup - start test server', async (toolsArg) => {
testServer = await startTestServer({ port: TEST_PORT });
await toolsArg.delayFor(1000);
});
tap.test('RFC 5321 - Server greeting format', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for initial greeting
const greeting = await waitForResponse(socket, '220');
console.log('Server greeting:', greeting.trim());
// RFC 5321: Server must provide proper 220 greeting
const greetingLine = greeting.trim();
const validGreeting = greetingLine.startsWith('220') && greetingLine.length > 10;
expect(validGreeting).toEqual(true);
expect(greetingLine).toMatch(/^220\s+\S+/); // Should have hostname after 220
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 5321 - EHLO response format', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
const ehloResponse = await waitForResponse(socket, '250');
console.log('Server response:', ehloResponse);
// RFC 5321: EHLO must return 250 with hostname and extensions
const ehloLines = ehloResponse.split('\r\n').filter(line => line.startsWith('250'));
expect(ehloLines.length).toBeGreaterThan(0);
expect(ehloLines[0]).toMatch(/^250[\s-]\S+/); // First line should have hostname
// Check for common extensions
const extensions = ehloLines.slice(1).map(line => line.substring(4).trim());
console.log('Extensions:', extensions);
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 5321 - Command case insensitivity', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Test lowercase command
socket.write('ehlo testclient\r\n');
await waitForResponse(socket, '250');
// Test mixed case command
socket.write('MaIl FrOm:<sender@example.com>\r\n');
await waitForResponse(socket, '250');
// Test uppercase command
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
// All case variations worked
console.log('All case variations accepted');
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 5321 - Line length limits', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// RFC 5321: Command line limit is 512 chars including CRLF
// Test with a long MAIL FROM command (but within limit)
const longDomain = 'a'.repeat(400);
socket.write(`MAIL FROM:<user@${longDomain}.com>\r\n`);
const response = await waitForResponse(socket);
// Should either accept (if within server limits) or reject gracefully
const accepted = response.includes('250');
const rejected = response.includes('501') || response.includes('500');
expect(accepted || rejected).toEqual(true);
console.log(`Long line test ${accepted ? 'accepted' : 'rejected'}`);
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 5321 - Standard SMTP verb compliance', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
const supportedVerbs: string[] = [];
// Wait for greeting
await waitForResponse(socket, '220');
// Try HELP command to see supported verbs
socket.write('HELP\r\n');
const helpResponse = await waitForResponse(socket);
// Parse HELP response for supported commands
if (helpResponse.includes('214') || helpResponse.includes('502')) {
// Either help text or command not implemented
}
// Test NOOP
socket.write('NOOP\r\n');
const noopResponse = await waitForResponse(socket);
if (noopResponse.includes('250')) {
supportedVerbs.push('NOOP');
}
// Test RSET
socket.write('RSET\r\n');
const rsetResponse = await waitForResponse(socket);
if (rsetResponse.includes('250')) {
supportedVerbs.push('RSET');
}
// Test VRFY
socket.write('VRFY test@example.com\r\n');
const vrfyResponse = await waitForResponse(socket);
// VRFY may be disabled for security (252 or 502)
if (vrfyResponse.includes('250') || vrfyResponse.includes('252')) {
supportedVerbs.push('VRFY');
}
// Check minimum required verbs
const requiredVerbs = ['NOOP', 'RSET'];
const hasRequired = requiredVerbs.every(verb =>
supportedVerbs.includes(verb) || verb === 'VRFY' // VRFY is optional
);
console.log('Supported verbs:', supportedVerbs);
expect(hasRequired).toEqual(true);
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 5321 - Required minimum extensions', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
const ehloResponse = await waitForResponse(socket, '250');
// Check for extensions
const lines = ehloResponse.split('\r\n');
const extensions = lines
.filter(line => line.startsWith('250-') || (line.startsWith('250 ') && lines.indexOf(line) > 0))
.map(line => line.substring(4).split(' ')[0].toUpperCase());
console.log('Server extensions:', extensions);
// RFC 5321 recommends these extensions
const recommendedExtensions = ['8BITMIME', 'SIZE', 'PIPELINING'];
const hasRecommended = recommendedExtensions.filter(ext => extensions.includes(ext));
console.log('Recommended extensions present:', hasRecommended);
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('cleanup - stop test server', async () => {
await stopTestServer(testServer);
});
tap.start();

428
test/suite/smtpserver_rfc-compliance/test.rfc-02.rfc5322-compliance.ts Normal file
View File

@ -0,0 +1,428 @@
import { tap, expect } from '@git.zone/tstest/tapbundle';
import * as plugins from '../../../ts/plugins.js';
import * as net from 'net';
import { startTestServer, stopTestServer } from '../../helpers/server.loader.js'
import type { ITestServer } from '../../helpers/server.loader.js';
const TEST_PORT = 2525;
let testServer: ITestServer;
// Helper function to wait for SMTP response
const waitForResponse = (socket: net.Socket, expectedCode?: string, timeout = 5000): Promise<string> => {
return new Promise((resolve, reject) => {
let buffer = '';
const timer = setTimeout(() => {
socket.removeListener('data', handler);
reject(new Error(`Timeout waiting for ${expectedCode || 'any'} response`));
}, timeout);
const handler = (data: Buffer) => {
buffer += data.toString();
const lines = buffer.split('\r\n');
// Check if we have a complete response
for (const line of lines) {
if (expectedCode) {
if (line.startsWith(expectedCode + ' ')) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
} else {
// Any complete response line
if (line.match(/^\d{3} /)) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
}
}
};
socket.on('data', handler);
});
};
tap.test('setup - start test server', async (toolsArg) => {
testServer = await startTestServer({ port: TEST_PORT });
await toolsArg.delayFor(1000);
});
tap.test('RFC 5322 - Message format with required headers', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Send MAIL FROM
socket.write('MAIL FROM:<sender@example.com>\r\n');
await waitForResponse(socket, '250');
// Send RCPT TO
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
// Send DATA
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// RFC 5322 compliant email with all required headers
const messageId = `<test.${Date.now()}@example.com>`;
const date = new Date().toUTCString();
const rfc5322Email = [
`Date: ${date}`,
`From: "Test Sender" <sender@example.com>`,
`To: "Test Recipient" <recipient@example.com>`,
`Subject: RFC 5322 Compliance Test`,
`Message-ID: ${messageId}`,
`MIME-Version: 1.0`,
`Content-Type: text/plain; charset=UTF-8`,
`Content-Transfer-Encoding: 7bit`,
'',
'This is a test message for RFC 5322 compliance verification.',
'It includes proper headers according to RFC 5322 specifications.',
'',
'Best regards,',
'Test System',
'.',
''
].join('\r\n');
socket.write(rfc5322Email);
const response = await waitForResponse(socket, '250');
console.log('RFC 5322 compliant message accepted');
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 5322 - Folded header lines', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Send MAIL FROM
socket.write('MAIL FROM:<sender@example.com>\r\n');
await waitForResponse(socket, '250');
// Send RCPT TO
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
// Send DATA
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// Test folded header lines (RFC 5322 section 2.2.3)
const email = [
`Date: ${new Date().toUTCString()}`,
`From: sender@example.com`,
`To: recipient@example.com`,
`Subject: This is a very long subject line that needs to be`,
` folded according to RFC 5322 specifications for proper`,
` email header formatting`,
`Message-ID: <${Date.now()}@example.com>`,
`References: <ref1@example.com>`,
` <ref2@example.com>`,
` <ref3@example.com>`,
'',
'Email with folded headers.',
'.',
''
].join('\r\n');
socket.write(email);
await waitForResponse(socket, '250');
console.log('Folded headers message accepted');
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 5322 - Multiple recipient formats', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Send MAIL FROM
socket.write('MAIL FROM:<sender@example.com>\r\n');
await waitForResponse(socket, '250');
// Send multiple RCPT TO
socket.write('RCPT TO:<recipient1@example.com>\r\n');
await waitForResponse(socket, '250');
socket.write('RCPT TO:<recipient2@example.com>\r\n');
await waitForResponse(socket, '250');
// Send DATA
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// Test various recipient formats allowed by RFC 5322
const email = [
`Date: ${new Date().toUTCString()}`,
`From: "Sender Name" <sender@example.com>`,
`To: recipient1@example.com, "Recipient Two" <recipient2@example.com>`,
`Cc: "Carbon Copy" <cc@example.com>`,
`Bcc: bcc@example.com`,
`Reply-To: "Reply Address" <reply@example.com>`,
`Subject: Multiple recipient formats test`,
`Message-ID: <${Date.now()}@example.com>`,
'',
'Testing various recipient header formats.',
'.',
''
].join('\r\n');
socket.write(email);
await waitForResponse(socket, '250');
console.log('Multiple recipient formats accepted');
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 5322 - Comments in headers', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Send MAIL FROM
socket.write('MAIL FROM:<sender@example.com>\r\n');
await waitForResponse(socket, '250');
// Send RCPT TO
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
// Send DATA
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// RFC 5322 allows comments in headers using parentheses
const email = [
`Date: ${new Date().toUTCString()} (generated by test system)`,
`From: sender@example.com (Test Sender)`,
`To: recipient@example.com (Primary Recipient)`,
`Subject: Testing comments (RFC 5322 section 3.2.2)`,
`Message-ID: <${Date.now()}@example.com>`,
`X-Custom-Header: value (with comment)`,
'',
'Email with comments in headers.',
'.',
''
].join('\r\n');
socket.write(email);
await waitForResponse(socket, '250');
console.log('Headers with comments accepted');
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 5322 - Resent headers', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Send MAIL FROM
socket.write('MAIL FROM:<resender@example.com>\r\n');
await waitForResponse(socket, '250');
// Send RCPT TO
socket.write('RCPT TO:<newrecipient@example.com>\r\n');
await waitForResponse(socket, '250');
// Send DATA
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// RFC 5322 resent headers for forwarded messages
const email = [
`Resent-Date: ${new Date().toUTCString()}`,
`Resent-From: resender@example.com`,
`Resent-To: newrecipient@example.com`,
`Resent-Message-ID: <resent.${Date.now()}@example.com>`,
`Date: ${new Date(Date.now() - 86400000).toUTCString()}`, // Original date (yesterday)
`From: original@example.com`,
`To: oldrecipient@example.com`,
`Subject: Forwarded: Original Subject`,
`Message-ID: <original.${Date.now() - 1000}@example.com>`,
'',
'This is a forwarded message with resent headers.',
'.',
''
].join('\r\n');
socket.write(email);
await waitForResponse(socket, '250');
console.log('Resent headers message accepted');
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('cleanup - stop test server', async () => {
await stopTestServer(testServer);
});
tap.start();

330
test/suite/smtpserver_rfc-compliance/test.rfc-03.rfc7208-spf-compliance.ts Normal file
View File

@ -0,0 +1,330 @@
import { tap, expect } from '@git.zone/tstest/tapbundle';
import * as plugins from '../../../ts/plugins.js';
import * as net from 'net';
import { startTestServer, stopTestServer } from '../../helpers/server.loader.js'
import type { ITestServer } from '../../helpers/server.loader.js';
const TEST_PORT = 2525;
let testServer: ITestServer;
// Helper function to wait for SMTP response
const waitForResponse = (socket: net.Socket, expectedCode?: string, timeout = 5000): Promise<string> => {
return new Promise((resolve, reject) => {
let buffer = '';
const timer = setTimeout(() => {
socket.removeListener('data', handler);
reject(new Error(`Timeout waiting for ${expectedCode || 'any'} response`));
}, timeout);
const handler = (data: Buffer) => {
buffer += data.toString();
const lines = buffer.split('\r\n');
// Check if we have a complete response
for (const line of lines) {
if (expectedCode) {
if (line.startsWith(expectedCode + ' ')) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
} else {
// Any complete response line
if (line.match(/^\d{3} /)) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
}
}
};
socket.on('data', handler);
});
};
tap.test('setup - start test server', async (toolsArg) => {
testServer = await startTestServer({ port: TEST_PORT });
await toolsArg.delayFor(1000);
});
tap.test('RFC 7208 SPF - Server handles SPF checks', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
const spfResults: any[] = [];
// Test domains simulating different SPF scenarios
const spfTestDomains = [
'spf-pass.example.com', // Should have valid SPF record allowing sender
'spf-fail.example.com', // Should have SPF record that fails
'spf-neutral.example.com', // Should have neutral SPF record
'no-spf.example.com' // Should have no SPF record
];
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
const ehloResponse = await waitForResponse(socket, '250');
// Check if server advertises SPF support
const advertisesSpf = ehloResponse.toLowerCase().includes('spf');
console.log('Server advertises SPF:', advertisesSpf);
// Test each domain
for (let i = 0; i < spfTestDomains.length; i++) {
const domain = spfTestDomains[i];
const testEmail = `spf-test@${domain}`;
spfResults[i] = {
domain: domain,
email: testEmail,
mailFromAccepted: false,
rcptAccepted: false,
spfFailed: false
};
console.log(`Testing SPF for domain: ${domain}`);
socket.write(`MAIL FROM:<${testEmail}>\r\n`);
const mailResponse = await waitForResponse(socket);
spfResults[i].mailFromResponse = mailResponse.trim();
if (mailResponse.includes('250')) {
// MAIL FROM accepted
spfResults[i].mailFromAccepted = true;
socket.write(`RCPT TO:<recipient@example.com>\r\n`);
const rcptResponse = await waitForResponse(socket);
if (rcptResponse.includes('250')) {
spfResults[i].rcptAccepted = true;
}
} else if (mailResponse.includes('550') || mailResponse.includes('553')) {
// SPF failure (expected for some domains)
spfResults[i].spfFailed = true;
}
// Reset for next test
socket.write('RSET\r\n');
await waitForResponse(socket, '250');
}
// All tests complete
console.log('SPF test results:', spfResults);
// Check that server handled all domains
const allDomainsHandled = spfResults.every(result =>
result.mailFromResponse !== undefined && result.mailFromResponse !== 'pending'
);
expect(allDomainsHandled).toEqual(true);
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 7208 SPF - SPF record syntax handling', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Test with domain that might have complex SPF record
socket.write('MAIL FROM:<test@gmail.com>\r\n');
const mailResponse = await waitForResponse(socket);
// Server should handle this appropriately (accept or reject based on SPF)
const handled = mailResponse.includes('250') ||
mailResponse.includes('550') ||
mailResponse.includes('553');
expect(handled).toEqual(true);
console.log('SPF handling response:', mailResponse.trim());
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 7208 SPF - Received-SPF header', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Send MAIL FROM
socket.write('MAIL FROM:<sender@example.com>\r\n');
await waitForResponse(socket, '250');
// Send RCPT TO
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
// Send DATA
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// Send email to check if server adds Received-SPF header
const email = [
`Date: ${new Date().toUTCString()}`,
`From: sender@example.com`,
`To: recipient@example.com`,
`Subject: SPF Header Test`,
`Message-ID: <${Date.now()}@example.com>`,
'',
'Testing if server adds Received-SPF header.',
'.',
''
].join('\r\n');
socket.write(email);
await waitForResponse(socket, '250');
console.log('Email accepted - server should process SPF');
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 7208 SPF - IPv4 and IPv6 mechanism support', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Test with IPv6 address representation
socket.write('EHLO [::1]\r\n');
await waitForResponse(socket, '250');
// Test domain with IP-based SPF mechanisms
socket.write('MAIL FROM:<test@ip-spf-test.com>\r\n');
const mailResponse = await waitForResponse(socket);
// Server should handle IP-based SPF mechanisms
const handled = mailResponse.includes('250') ||
mailResponse.includes('550') ||
mailResponse.includes('553');
expect(handled).toEqual(true);
console.log('IP mechanism SPF response:', mailResponse.trim());
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('cleanup - stop test server', async () => {
await stopTestServer(testServer);
});
tap.start();

450
test/suite/smtpserver_rfc-compliance/test.rfc-04.rfc6376-dkim-compliance.ts Normal file
View File

@ -0,0 +1,450 @@
import { tap, expect } from '@git.zone/tstest/tapbundle';
import * as plugins from '../../../ts/plugins.js';
import * as net from 'net';
import { startTestServer, stopTestServer } from '../../helpers/server.loader.js'
import type { ITestServer } from '../../helpers/server.loader.js';
const TEST_PORT = 2525;
let testServer: ITestServer;
// Helper function to wait for SMTP response
const waitForResponse = (socket: net.Socket, expectedCode?: string, timeout = 5000): Promise<string> => {
return new Promise((resolve, reject) => {
let buffer = '';
const timer = setTimeout(() => {
socket.removeListener('data', handler);
reject(new Error(`Timeout waiting for ${expectedCode || 'any'} response`));
}, timeout);
const handler = (data: Buffer) => {
buffer += data.toString();
const lines = buffer.split('\r\n');
// Check if we have a complete response
for (const line of lines) {
if (expectedCode) {
if (line.startsWith(expectedCode + ' ')) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
} else {
// Any complete response line
if (line.match(/^\d{3} /)) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
}
}
};
socket.on('data', handler);
});
};
tap.test('setup - start test server', async (toolsArg) => {
testServer = await startTestServer({ port: TEST_PORT });
await toolsArg.delayFor(1000);
});
tap.test('RFC 6376 DKIM - Server accepts email with DKIM signature', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Send MAIL FROM
socket.write('MAIL FROM:<sender@example.com>\r\n');
await waitForResponse(socket, '250');
// Send RCPT TO
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
// Send DATA
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// Create email with DKIM signature
const dkimSignature = [
'DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;',
' d=example.com; s=default;',
' h=from:to:subject:date:message-id;',
' bh=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN/XKdLCPjaYaY=;',
' b=Kt1zLCYmUVYJKEOVL9nGF2JVPJ5/k5l6yOkNBJGCrZn4E5z9Qn7TlYrG8QfBgJ4',
' CzYVLjKm5xOhUoEaDzTJ1E6C9A4hL8sKfBxQjN8oWv4kP3GdE6mFqS0wKcRjT+',
' NxOz2VcJP4LmKjFsG8XqBhYoEfCvSr3UwNmEkP6RjT9WlQzA4kJe2VoMsJ='
].join('\r\n');
const email = [
`From: sender@example.com`,
`To: recipient@example.com`,
`Subject: DKIM RFC 6376 Compliance Test`,
`Date: ${new Date().toUTCString()}`,
`Message-ID: <dkim-test-${Date.now()}@example.com>`,
dkimSignature,
'',
'This email tests RFC 6376 DKIM compliance.',
'The server should properly handle DKIM signatures.',
'.',
''
].join('\r\n');
socket.write(email);
await waitForResponse(socket, '250');
console.log('Email with DKIM signature accepted');
expect(true).toEqual(true); // Server accepts DKIM headers
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 6376 DKIM - Multiple DKIM signatures', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Send MAIL FROM
socket.write('MAIL FROM:<sender@example.com>\r\n');
await waitForResponse(socket, '250');
// Send RCPT TO
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
// Send DATA
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// Email with multiple DKIM signatures (common in forwarding scenarios)
const email = [
`From: sender@example.com`,
`To: recipient@example.com`,
`Subject: Multiple DKIM Signatures Test`,
`Date: ${new Date().toUTCString()}`,
`Message-ID: <multi-dkim-${Date.now()}@example.com>`,
'DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;',
' d=example.com; s=selector1;',
' h=from:to:subject:date;',
' bh=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN/XKdLCPjaYaY=;',
' b=signature1data',
'DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple;',
' d=forwarder.com; s=selector2;',
' h=from:to:subject:date:message-id;',
' bh=differentbodyhash=;',
' b=signature2data',
'',
'Email with multiple DKIM signatures.',
'.',
''
].join('\r\n');
socket.write(email);
await waitForResponse(socket, '250');
console.log('Email with multiple DKIM signatures accepted');
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 6376 DKIM - Various canonicalization methods', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Send MAIL FROM
socket.write('MAIL FROM:<sender@example.com>\r\n');
await waitForResponse(socket, '250');
// Send RCPT TO
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
// Send DATA
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// Test different canonicalization methods
const email = [
`From: sender@example.com`,
`To: recipient@example.com`,
`Subject: DKIM Canonicalization Test`,
`Date: ${new Date().toUTCString()}`,
`Message-ID: <canon-${Date.now()}@example.com>`,
'DKIM-Signature: v=1; a=rsa-sha256; c=simple/relaxed;',
' d=example.com; s=default;',
' h=from:to:subject;',
' bh=bodyhash=;',
' b=signature',
'',
'Testing different canonicalization methods.',
'Simple header canonicalization preserves whitespace.',
'Relaxed body canonicalization normalizes whitespace.',
'.',
''
].join('\r\n');
socket.write(email);
await waitForResponse(socket, '250');
console.log('Email with different canonicalization accepted');
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 6376 DKIM - Long header fields and folding', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Send MAIL FROM
socket.write('MAIL FROM:<sender@example.com>\r\n');
await waitForResponse(socket, '250');
// Send RCPT TO
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
// Send DATA
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// DKIM signature with long fields that require folding
const longSignature = 'b=' + 'A'.repeat(200);
const email = [
`From: sender@example.com`,
`To: recipient@example.com`,
`Subject: DKIM Long Fields Test`,
`Date: ${new Date().toUTCString()}`,
`Message-ID: <long-dkim-${Date.now()}@example.com>`,
'DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;',
' d=example.com; s=default; t=' + Math.floor(Date.now() / 1000) + ';',
' h=from:to:subject:date:message-id:content-type:mime-version;',
' bh=verylongbodyhashvalueherethatexceedsnormallength1234567890=;',
' ' + longSignature.substring(0, 70),
' ' + longSignature.substring(70, 140),
' ' + longSignature.substring(140),
'',
'Testing DKIM with long header fields.',
'.',
''
].join('\r\n');
socket.write(email);
await waitForResponse(socket, '250');
console.log('Email with long DKIM fields accepted');
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 6376 DKIM - Authentication-Results header', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
const ehloResponse = await waitForResponse(socket, '250');
// Check if server advertises DKIM support
const advertisesDkim = ehloResponse.toLowerCase().includes('dkim');
console.log('Server advertises DKIM:', advertisesDkim);
// Send MAIL FROM
socket.write('MAIL FROM:<sender@example.com>\r\n');
await waitForResponse(socket, '250');
// Send RCPT TO
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
// Send DATA
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// Email to test if server adds Authentication-Results header
const email = [
`From: sender@example.com`,
`To: recipient@example.com`,
`Subject: Authentication-Results Test`,
`Date: ${new Date().toUTCString()}`,
`Message-ID: <auth-results-${Date.now()}@example.com>`,
'DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;',
' d=example.com; s=default;',
' h=from:to:subject;',
' bh=simplehash=;',
' b=simplesignature',
'',
'Testing if server adds Authentication-Results header.',
'.',
''
].join('\r\n');
socket.write(email);
await waitForResponse(socket, '250');
console.log('Email accepted - server should process DKIM and potentially add Authentication-Results');
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('cleanup - stop test server', async () => {
await stopTestServer(testServer);
});
tap.start();

408
test/suite/smtpserver_rfc-compliance/test.rfc-05.rfc7489-dmarc-compliance.ts Normal file
View File

@ -0,0 +1,408 @@
import { tap, expect } from '@git.zone/tstest/tapbundle';
import * as plugins from '../../../ts/plugins.js';
import * as net from 'net';
import { startTestServer, stopTestServer } from '../../helpers/server.loader.js'
import type { ITestServer } from '../../helpers/server.loader.js';
const TEST_PORT = 2525;
let testServer: ITestServer;
// Helper function to wait for SMTP response
const waitForResponse = (socket: net.Socket, expectedCode?: string, timeout = 5000): Promise<string> => {
return new Promise((resolve, reject) => {
let buffer = '';
const timer = setTimeout(() => {
socket.removeListener('data', handler);
reject(new Error(`Timeout waiting for ${expectedCode || 'any'} response`));
}, timeout);
const handler = (data: Buffer) => {
buffer += data.toString();
const lines = buffer.split('\r\n');
// Check if we have a complete response
for (const line of lines) {
if (expectedCode) {
if (line.startsWith(expectedCode + ' ')) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
} else {
// Any complete response line
if (line.match(/^\d{3} /)) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
}
}
};
socket.on('data', handler);
});
};
tap.test('setup - start test server', async (toolsArg) => {
testServer = await startTestServer({ port: TEST_PORT });
await toolsArg.delayFor(1000);
});
tap.test('RFC 7489 DMARC - Server handles DMARC policies', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
const dmarcResults: any[] = [];
// Test domains simulating different DMARC policies
const dmarcTestScenarios = [
{
domain: 'dmarc-reject.example.com',
policy: 'reject',
alignment: 'strict'
},
{
domain: 'dmarc-quarantine.example.com',
policy: 'quarantine',
alignment: 'relaxed'
},
{
domain: 'dmarc-none.example.com',
policy: 'none',
alignment: 'relaxed'
}
];
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
const ehloResponse = await waitForResponse(socket, '250');
// Check if server advertises DMARC support
const advertisesDmarc = ehloResponse.toLowerCase().includes('dmarc');
console.log('Server advertises DMARC:', advertisesDmarc);
// Test each scenario
for (let i = 0; i < dmarcTestScenarios.length; i++) {
const scenario = dmarcTestScenarios[i];
const testFromAddress = `dmarc-test@${scenario.domain}`;
dmarcResults[i] = {
domain: scenario.domain,
policy: scenario.policy,
mailFromAccepted: false,
rcptAccepted: false
};
console.log(`Testing DMARC policy: ${scenario.policy} for domain: ${scenario.domain}`);
socket.write(`MAIL FROM:<${testFromAddress}>\r\n`);
const mailResponse = await waitForResponse(socket);
dmarcResults[i].mailFromResponse = mailResponse.trim();
if (mailResponse.includes('250')) {
dmarcResults[i].mailFromAccepted = true;
socket.write(`RCPT TO:<recipient@example.com>\r\n`);
const rcptResponse = await waitForResponse(socket);
if (rcptResponse.includes('250')) {
dmarcResults[i].rcptAccepted = true;
// Send DATA
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// Send email with DMARC-relevant headers
const email = [
`From: dmarc-test@${scenario.domain}`,
`To: recipient@example.com`,
`Subject: DMARC RFC 7489 Compliance Test - ${scenario.policy}`,
`Date: ${new Date().toUTCString()}`,
`Message-ID: <dmarc-test-${scenario.policy}-${Date.now()}@${scenario.domain}>`,
`DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=${scenario.domain}; s=default;`,
` h=from:to:subject:date; bh=testbodyhash; b=testsignature`,
`Authentication-Results: example.org; spf=pass smtp.mailfrom=${scenario.domain}`,
'',
`This email tests DMARC ${scenario.policy} policy compliance.`,
'The server should handle DMARC policies according to RFC 7489.',
'.',
''
].join('\r\n');
socket.write(email);
const dataResponse = await waitForResponse(socket, '250');
dmarcResults[i].emailAccepted = true;
console.log(`DMARC ${scenario.policy} policy email accepted`);
}
} else if (mailResponse.includes('550') || mailResponse.includes('553')) {
// DMARC policy rejection (expected for some scenarios)
dmarcResults[i].dmarcRejected = true;
dmarcResults[i].rejectionResponse = mailResponse.trim();
console.log(`DMARC ${scenario.policy} policy rejected as expected`);
}
// Reset for next test
socket.write('RSET\r\n');
await waitForResponse(socket, '250');
}
// All tests complete
console.log('DMARC test results:', dmarcResults);
// Check that server handled all scenarios
const allScenariosHandled = dmarcResults.every(result =>
result.mailFromResponse !== undefined
);
expect(allScenariosHandled).toEqual(true);
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 7489 DMARC - Alignment testing', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Test misaligned domain (envelope vs header)
socket.write('MAIL FROM:<sender@envelope-domain.com>\r\n');
await waitForResponse(socket, '250');
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// Email with different header From domain (testing alignment)
const email = [
`From: sender@header-domain.com`,
`To: recipient@example.com`,
`Subject: DMARC Alignment Test`,
`Date: ${new Date().toUTCString()}`,
`Message-ID: <alignment-${Date.now()}@header-domain.com>`,
`DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=header-domain.com; s=default;`,
` h=from:to:subject:date; bh=alignmenthash; b=alignmentsig`,
'',
'Testing DMARC domain alignment (envelope vs header From).',
'.',
''
].join('\r\n');
socket.write(email);
const response = await waitForResponse(socket);
const accepted = response.includes('250');
console.log(`Alignment test ${accepted ? 'accepted' : 'rejected due to alignment failure'}`);
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 7489 DMARC - Subdomain policy', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Test subdomain policy inheritance
socket.write('MAIL FROM:<sender@subdomain.dmarc-policy.com>\r\n');
await waitForResponse(socket, '250');
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// Email from subdomain to test policy inheritance
const email = [
`From: sender@subdomain.dmarc-policy.com`,
`To: recipient@example.com`,
`Subject: DMARC Subdomain Policy Test`,
`Date: ${new Date().toUTCString()}`,
`Message-ID: <subdomain-${Date.now()}@subdomain.dmarc-policy.com>`,
`DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=subdomain.dmarc-policy.com; s=default;`,
` h=from:to:subject:date; bh=subdomainhash; b=subdomainsig`,
'',
'Testing DMARC subdomain policy inheritance.',
'.',
''
].join('\r\n');
socket.write(email);
const response = await waitForResponse(socket);
const accepted = response.includes('250');
console.log(`Subdomain policy test ${accepted ? 'accepted' : 'rejected'}`);
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 7489 DMARC - Report generation hint', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
socket.write('MAIL FROM:<dmarc-report@example.com>\r\n');
await waitForResponse(socket, '250');
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// Email with DMARC report request headers
const email = [
`From: dmarc-report@example.com`,
`To: recipient@example.com`,
`Subject: DMARC Report Generation Test`,
`Date: ${new Date().toUTCString()}`,
`Message-ID: <report-${Date.now()}@example.com>`,
`DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=example.com; s=default;`,
` h=from:to:subject:date; bh=reporthash; b=reportsig`,
`Authentication-Results: mta.example.com;`,
` dmarc=pass (p=none dis=none) header.from=example.com`,
'',
'Testing DMARC report generation capabilities.',
'Server should log DMARC results for reporting.',
'.',
''
].join('\r\n');
socket.write(email);
await waitForResponse(socket, '250');
console.log('DMARC report test email accepted');
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('cleanup - stop test server', async () => {
await stopTestServer(testServer);
});
tap.start();

366
test/suite/smtpserver_rfc-compliance/test.rfc-06.rfc8314-tls-compliance.ts Normal file
View File

@ -0,0 +1,366 @@
import { tap, expect } from '@git.zone/tstest/tapbundle';
import * as plugins from '../../../ts/plugins.js';
import * as net from 'net';
import * as tls from 'tls';
import { startTestServer, stopTestServer } from '../../helpers/server.loader.js'
import type { ITestServer } from '../../helpers/server.loader.js';
const TEST_PORT = 2525;
let testServer: ITestServer;
// Helper function to wait for SMTP response
const waitForResponse = (socket: net.Socket, expectedCode?: string, timeout = 5000): Promise<string> => {
return new Promise((resolve, reject) => {
let buffer = '';
const timer = setTimeout(() => {
socket.removeListener('data', handler);
reject(new Error(`Timeout waiting for ${expectedCode || 'any'} response`));
}, timeout);
const handler = (data: Buffer) => {
buffer += data.toString();
const lines = buffer.split('\r\n');
// Check if we have a complete response
for (const line of lines) {
if (expectedCode) {
if (line.startsWith(expectedCode + ' ')) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
} else {
// Any complete response line
if (line.match(/^\d{3} /)) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
}
}
};
socket.on('data', handler);
});
};
tap.test('setup - start test server', async (toolsArg) => {
testServer = await startTestServer({ port: TEST_PORT });
await toolsArg.delayFor(1000);
});
tap.test('RFC 8314 TLS - STARTTLS advertised in EHLO', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
const ehloResponse = await waitForResponse(socket, '250');
// Check if STARTTLS is advertised (RFC 8314 requirement)
const advertisesStarttls = ehloResponse.toLowerCase().includes('starttls');
console.log('STARTTLS advertised:', advertisesStarttls);
expect(advertisesStarttls).toEqual(true);
// Parse other extensions
const lines = ehloResponse.split('\r\n');
const extensions = lines
.filter(line => line.startsWith('250-') || (line.startsWith('250 ') && lines.indexOf(line) > 0))
.map(line => line.substring(4).split(' ')[0].toUpperCase());
console.log('Server extensions:', extensions);
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 8314 TLS - STARTTLS command functionality', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
const ehloResponse = await waitForResponse(socket, '250');
const advertisesStarttls = ehloResponse.toLowerCase().includes('starttls');
if (advertisesStarttls) {
// Send STARTTLS
socket.write('STARTTLS\r\n');
const starttlsResponse = await waitForResponse(socket, '220');
console.log('STARTTLS command accepted, ready to upgrade');
// In a real test, we would upgrade to TLS here
// For this test, we just verify the command is accepted
expect(true).toEqual(true);
} else {
console.log('STARTTLS not advertised, skipping upgrade');
}
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 8314 TLS - Commands before STARTTLS', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Try MAIL FROM before STARTTLS (server may require TLS first)
socket.write('MAIL FROM:<sender@example.com>\r\n');
const mailResponse = await waitForResponse(socket);
// Server may accept or reject based on TLS policy
if (mailResponse.includes('250')) {
console.log('Server allows MAIL FROM before STARTTLS');
} else if (mailResponse.includes('530') || mailResponse.includes('554')) {
console.log('Server requires STARTTLS before MAIL FROM (RFC 8314 compliant)');
expect(true).toEqual(true); // This is actually good for security
}
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 8314 TLS - TLS version support', async (tools) => {
const done = tools.defer();
// First establish plain connection to get STARTTLS
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Send STARTTLS
socket.write('STARTTLS\r\n');
const starttlsResponse = await waitForResponse(socket, '220');
console.log('Ready to upgrade to TLS');
// Upgrade connection to TLS
const tlsOptions = {
socket: socket,
rejectUnauthorized: false, // For testing
minVersion: 'TLSv1.2' as any // RFC 8314 recommends TLS 1.2 or higher
};
const tlsSocket = tls.connect(tlsOptions);
tlsSocket.on('secureConnect', () => {
console.log('TLS connection established');
console.log('Protocol:', tlsSocket.getProtocol());
console.log('Cipher:', tlsSocket.getCipher());
// Verify TLS 1.2 or higher
const protocol = tlsSocket.getProtocol();
if (protocol) {
expect(['TLSv1.2', 'TLSv1.3']).toContain(protocol);
}
tlsSocket.write('EHLO testclient\r\n');
});
tlsSocket.on('data', (data) => {
const response = data.toString();
console.log('TLS response:', response);
if (response.includes('250')) {
console.log('EHLO after STARTTLS successful');
tlsSocket.write('QUIT\r\n');
setTimeout(() => {
tlsSocket.end();
done.resolve();
}, 100);
}
});
tlsSocket.on('error', (err) => {
console.error('TLS error:', err);
// If TLS upgrade fails, still pass the test as server accepted STARTTLS
done.resolve();
});
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 8314 TLS - Email submission after STARTTLS', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// For this test, proceed without STARTTLS to test basic functionality
socket.write('MAIL FROM:<sender@example.com>\r\n');
const mailResponse = await waitForResponse(socket);
if (mailResponse.includes('250')) {
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
const email = [
`Date: ${new Date().toUTCString()}`,
`From: sender@example.com`,
`To: recipient@example.com`,
`Subject: RFC 8314 TLS Compliance Test`,
`Message-ID: <tls-test-${Date.now()}@example.com>`,
'',
'Testing email submission with TLS requirements.',
'.',
''
].join('\r\n');
socket.write(email);
await waitForResponse(socket, '250');
console.log('Email accepted (server allows non-TLS or we are testing on TLS port)');
} else {
// Server may require STARTTLS first
console.log('Server requires STARTTLS for mail submission');
}
// Send QUIT
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('cleanup - stop test server', async () => {
await stopTestServer(testServer);
});
tap.start();

399
test/suite/smtpserver_rfc-compliance/test.rfc-07.rfc3461-dsn-compliance.ts Normal file
View File

@ -0,0 +1,399 @@
import { tap, expect } from '@git.zone/tstest/tapbundle';
import * as plugins from '../../../ts/plugins.js';
import * as net from 'net';
import { startTestServer, stopTestServer } from '../../helpers/server.loader.js'
import type { ITestServer } from '../../helpers/server.loader.js';
const TEST_PORT = 2525;
let testServer: ITestServer;
// Helper function to wait for SMTP response
const waitForResponse = (socket: net.Socket, expectedCode?: string, timeout = 5000): Promise<string> => {
return new Promise((resolve, reject) => {
let buffer = '';
const timer = setTimeout(() => {
socket.removeListener('data', handler);
reject(new Error(`Timeout waiting for ${expectedCode || 'any'} response`));
}, timeout);
const handler = (data: Buffer) => {
buffer += data.toString();
const lines = buffer.split('\r\n');
// Check if we have a complete response
for (const line of lines) {
if (expectedCode) {
if (line.startsWith(expectedCode + ' ')) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
} else {
// Any complete response line
if (line.match(/^\d{3} /)) {
clearTimeout(timer);
socket.removeListener('data', handler);
resolve(buffer);
return;
}
}
}
};
socket.on('data', handler);
});
};
tap.test('setup - start test server', async (toolsArg) => {
testServer = await startTestServer({ port: TEST_PORT });
await toolsArg.delayFor(1000);
});
tap.test('RFC 3461 DSN - DSN extension advertised', async (tools) => {
const done = tools.defer();
try {
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
await new Promise<void>((resolve, reject) => {
socket.once('connect', resolve);
socket.once('error', reject);
});
// Read greeting
const greeting = await waitForResponse(socket, '220');
console.log('Server response:', greeting);
// Send EHLO
socket.write('EHLO testclient\r\n');
const ehloResponse = await waitForResponse(socket, '250');
console.log('Server response:', ehloResponse);
// Check if DSN extension is advertised
const advertisesDsn = ehloResponse.toLowerCase().includes('dsn');
console.log('DSN extension advertised:', advertisesDsn);
// Parse extensions
const lines = ehloResponse.split('\r\n');
const extensions = lines
.filter(line => line.startsWith('250-') || (line.startsWith('250 ') && lines.indexOf(line) > 0))
.map(line => line.substring(4).split(' ')[0].toUpperCase());
console.log('Server extensions:', extensions);
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (error) {
console.error('Socket error:', error);
done.reject(error);
}
});
tap.test('RFC 3461 DSN - MAIL FROM with DSN parameters', async (tools) => {
const done = tools.defer();
try {
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
await new Promise<void>((resolve, reject) => {
socket.once('connect', resolve);
socket.once('error', reject);
});
// Read greeting
const greeting = await waitForResponse(socket, '220');
console.log('Server response:', greeting);
// Send EHLO
socket.write('EHLO testclient\r\n');
const ehloResponse = await waitForResponse(socket, '250');
console.log('Server response:', ehloResponse);
// Test MAIL FROM with DSN parameters (RFC 3461)
socket.write('MAIL FROM:<sender@example.com> RET=FULL ENVID=test-envelope-123\r\n');
const mailResponse = await waitForResponse(socket);
console.log('Server response:', mailResponse);
// Server should either accept (250) or reject with proper error
const accepted = mailResponse.includes('250');
const properlyRejected = mailResponse.includes('501') || mailResponse.includes('555');
expect(accepted || properlyRejected).toEqual(true);
console.log(`DSN parameters in MAIL FROM ${accepted ? 'accepted' : 'rejected'}`);
if (accepted) {
// Reset to test other parameters
socket.write('RSET\r\n');
const resetResponse = await waitForResponse(socket, '250');
console.log('Server response:', resetResponse);
// Test with RET=HDRS
socket.write('MAIL FROM:<sender@example.com> RET=HDRS\r\n');
const mailHdrsResponse = await waitForResponse(socket);
console.log('Server response:', mailHdrsResponse);
const hdrsAccepted = mailHdrsResponse.includes('250');
console.log(`RET=HDRS parameter ${hdrsAccepted ? 'accepted' : 'rejected'}`);
}
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (error) {
console.error('Socket error:', error);
done.reject(error);
}
});
tap.test('RFC 3461 DSN - RCPT TO with DSN parameters', async (tools) => {
const done = tools.defer();
try {
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
await new Promise<void>((resolve, reject) => {
socket.once('connect', resolve);
socket.once('error', reject);
});
// Read greeting
const greeting = await waitForResponse(socket, '220');
console.log('Server response:', greeting);
// Send EHLO
socket.write('EHLO testclient\r\n');
const ehloResponse = await waitForResponse(socket, '250');
console.log('Server response:', ehloResponse);
// Send MAIL FROM
socket.write('MAIL FROM:<sender@example.com>\r\n');
const mailResponse = await waitForResponse(socket, '250');
console.log('Server response:', mailResponse);
// Test RCPT TO with DSN parameters
socket.write('RCPT TO:<recipient@example.com> NOTIFY=SUCCESS,FAILURE ORCPT=rfc822;recipient@example.com\r\n');
const rcptResponse = await waitForResponse(socket);
console.log('Server response:', rcptResponse);
// Server should either accept (250) or reject with proper error
const accepted = rcptResponse.includes('250');
const properlyRejected = rcptResponse.includes('501') || rcptResponse.includes('555');
expect(accepted || properlyRejected).toEqual(true);
console.log(`DSN parameters in RCPT TO ${accepted ? 'accepted' : 'rejected'}`);
if (accepted) {
// Reset to test other notify values
socket.write('RSET\r\n');
const resetResponse = await waitForResponse(socket, '250');
console.log('Server response:', resetResponse);
// Send MAIL FROM again
socket.write('MAIL FROM:<sender@example.com>\r\n');
const mail2Response = await waitForResponse(socket, '250');
console.log('Server response:', mail2Response);
// Test NOTIFY=NEVER
socket.write('RCPT TO:<recipient@example.com> NOTIFY=NEVER\r\n');
const rcptNeverResponse = await waitForResponse(socket);
console.log('Server response:', rcptNeverResponse);
const neverAccepted = rcptNeverResponse.includes('250');
console.log(`NOTIFY=NEVER parameter ${neverAccepted ? 'accepted' : 'rejected'}`);
}
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (error) {
console.error('Socket error:', error);
done.reject(error);
}
});
tap.test('RFC 3461 DSN - Complete DSN-enabled email', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Try with DSN parameters
socket.write('MAIL FROM:<sender@example.com> RET=FULL ENVID=test123\r\n');
const mailResponse = await waitForResponse(socket);
if (mailResponse.includes('250')) {
// DSN parameters accepted, continue with DSN RCPT
socket.write('RCPT TO:<recipient@example.com> NOTIFY=SUCCESS,FAILURE,DELAY\r\n');
const rcptResponse = await waitForResponse(socket);
if (!rcptResponse.includes('250')) {
// Fallback to plain RCPT if DSN parameters not supported
console.log('DSN RCPT parameters not supported, using plain RCPT TO');
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
}
} else if (mailResponse.includes('501') || mailResponse.includes('555')) {
// DSN not supported, use plain MAIL FROM
console.log('DSN parameters not supported, using plain MAIL FROM');
socket.write('MAIL FROM:<sender@example.com>\r\n');
await waitForResponse(socket, '250');
socket.write('RCPT TO:<recipient@example.com>\r\n');
await waitForResponse(socket, '250');
}
// Send DATA
socket.write('DATA\r\n');
await waitForResponse(socket, '354');
// Send email content
const email = [
`From: sender@example.com`,
`To: recipient@example.com`,
`Subject: RFC 3461 DSN Compliance Test`,
`Date: ${new Date().toUTCString()}`,
`Message-ID: <dsn-test-${Date.now()}@example.com>`,
'',
'This email tests RFC 3461 DSN (Delivery Status Notification) compliance.',
'The server should handle DSN parameters according to RFC 3461.',
'.',
''
].join('\r\n');
socket.write(email);
await waitForResponse(socket, '250');
console.log('DSN-enabled email accepted');
// Quit
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('RFC 3461 DSN - Invalid DSN parameter handling', async (tools) => {
const done = tools.defer();
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
socket.on('error', (err) => {
console.error('Socket error:', err);
done.reject(err);
});
socket.on('connect', async () => {
try {
// Wait for greeting
await waitForResponse(socket, '220');
// Send EHLO
socket.write('EHLO testclient\r\n');
await waitForResponse(socket, '250');
// Test with invalid RET value
socket.write('MAIL FROM:<sender@example.com> RET=INVALID\r\n');
const mailResponse = await waitForResponse(socket);
// Should reject with 501 or similar
const properlyRejected = mailResponse.includes('501') ||
mailResponse.includes('555') ||
mailResponse.includes('500');
if (properlyRejected) {
console.log('Invalid RET parameter properly rejected');
expect(true).toEqual(true);
} else if (mailResponse.includes('250')) {
// Server ignores unknown parameters (also acceptable)
console.log('Server ignores invalid DSN parameters');
}
// Reset and test invalid NOTIFY
socket.write('RSET\r\n');
await waitForResponse(socket, '250');
socket.write('MAIL FROM:<sender@example.com>\r\n');
await waitForResponse(socket, '250');
// Test with invalid NOTIFY value
socket.write('RCPT TO:<recipient@example.com> NOTIFY=INVALID\r\n');
const rcptResponse = await waitForResponse(socket);
const rcptRejected = rcptResponse.includes('501') ||
rcptResponse.includes('555') ||
rcptResponse.includes('500');
if (rcptRejected) {
console.log('Invalid NOTIFY parameter properly rejected');
} else if (rcptResponse.includes('250')) {
console.log('Server ignores invalid NOTIFY parameter');
}
// Quit
socket.write('QUIT\r\n');
await waitForResponse(socket, '221');
socket.end();
done.resolve();
} catch (err) {
console.error('Test error:', err);
socket.end();
done.reject(err);
}
});
await done.promise;
});
tap.test('cleanup - stop test server', async () => {
await stopTestServer(testServer);
});
tap.start();