dsh-instruction-memory 1.4.0 → 1.4.2

package/lib/mailer.js

@@ -100,10 +100,30 @@ const MAX_FEEDBACK_COOLDOWN_MS = 10 * 60_000
 /** SMTP defaults: implicit TLS on 465, STARTTLS on 587. */
 const DEFAULT_SECURE_PORT = 465
 const DEFAULT_PLAIN_PORT = 587
+/** Idle timeout of one protocol step. */
 const SMTP_TIMEOUT_MS = 20_000
+/**
+ * Ceiling for a whole delivery. Every step may idle for SMTP_TIMEOUT_MS, so
+ * without an overall bound a slow peer keeps the request open far longer than
+ * the panel waits: the user is told "timeout" while the mail is still being
+ * delivered, and a retry duplicates it.
+ */
+export const SMTP_TOTAL_TIMEOUT_MS = 60_000
+/**
+ * Upper bound for one response line. A peer that never sends CRLF must not be
+ * able to grow the read buffer without limit.
+ */
+const MAX_RESPONSE_BYTES = 64 * 1024
 
-/** One mailbox check. Deliberately permissive: the SMTP server is the authority. */
-const EMAIL_RE = /^[^\s@<>()[\],;:"]+@[^\s@<>()[\],;:"]+$/
+/**
+ * One mailbox check. The local part stays permissive (the SMTP server is the
+ * authority) but control bytes and newlines never pass, and non-ASCII is
+ * rejected on purpose: SMTPUTF8 is not implemented, so an internationalised
+ * address would leave as a raw 8-bit header and be refused — a readable message
+ * here beats a mangled envelope.
+ */
+const EMAIL_RE = /^[^\s@<>()[\],;:"\u0000-\u001f\u007f-\u009f]+@[^\s@<>()[\],;:"\u0000-\u001f\u007f-\u009f]+$/
+const ASCII_RE = /^[\x20-\x7e]+$/
 
 const textOf = (value) => (typeof value === 'string' ? value.trim() : '')
 const envText = (env, name) => (env !== null && typeof env === 'object' && typeof env[name] === 'string' ? env[name].trim() : '')
@@ -120,6 +140,30 @@ const scalarText = (value) => {
   return ''
 }
 
+/**
+ * Whether an address may be used in an envelope or a header, with the reason
+ * when it may not (a fragment so callers can name the field themselves).
+ */
+function mailboxVerdict(address) {
+  const text = textOf(address)
+  if (text === '' || !EMAIL_RE.test(text)) return '格式不正确'
+  if (!ASCII_RE.test(text)) return '含非 ASCII 字符（SMTPUTF8 未启用，暂不支持）'
+  return ''
+}
+const isMailbox = (address) => mailboxVerdict(address) === ''
+
+/**
+ * A header field and an SMTP command are single lines. Anything else is a
+ * forgery attempt: refuse it here instead of trusting the caller to have
+ * validated an address first.
+ */
+function assertHeaderSafe(value, field) {
+  const text = String(value === null || value === undefined ? '' : value)
+  if (/[\r\n]/.test(text)) throw new Error(field + '不能包含换行符')
+  if (/[\u0000-\u001f\u007f]/.test(text)) throw new Error(field + '不能包含控制字符')
+  return text
+}
+
 /**
  * Remove control characters that could forge a new header or an SMTP command.
  * Newlines inside the body are legitimate and survive; every other field is
@@ -336,8 +380,18 @@ export function feedbackConfigFrom(options = {}) {
   const fileSmtp = file.smtp !== null && typeof file.smtp === 'object' && !Array.isArray(file.smtp) ? file.smtp : {}
   const configPath = textOf(options.configPath)
 
-  let to = envText(env, FEEDBACK_ENV.to) || textOf(file.to)
+  const fileTo = textOf(file.to)
   const encryptedTo = textOf(file.toEncrypted)
+  if (fileTo !== '' && encryptedTo !== '') {
+    // Silently preferring one of them would either leave the address in clear
+    // text while the operator believes the encryption is in force, or hide a
+    // broken ciphertext. Both are configuration mistakes worth refusing.
+    return {
+      ok: false,
+      message: '配置文件同时包含 to 与 toEncrypted：请删除明文 to（否则收件邮箱仍以明文保存，加密不生效）。',
+    }
+  }
+  let to = envText(env, FEEDBACK_ENV.to) || fileTo
   const secret = envText(env, FEEDBACK_ENV.secret)
   const explicitHost = envText(env, FEEDBACK_ENV.host)
 
@@ -366,9 +420,16 @@ export function feedbackConfigFrom(options = {}) {
   const user = envText(env, FEEDBACK_ENV.user)
     || (urlConfig === null ? '' : urlConfig.user)
     || textOf(fileSmtp.user)
+  const passFromFile = scalarText(fileSmtp.pass)
+  if (fileSmtp.pass !== undefined && fileSmtp.pass !== null && fileSmtp.pass !== '' && passFromFile === '') {
+    // A JSON number is fine (scalarText stringifies it, like port/secure); an
+    // object or array would otherwise be dropped silently and surface as a
+    // wrong-password failure nobody can explain.
+    return { ok: false, message: '配置文件 smtp.pass 类型无效：请写成字符串' }
+  }
   const pass = envText(env, FEEDBACK_ENV.pass) !== ''
     ? envText(env, FEEDBACK_ENV.pass)
-    : ((urlConfig === null ? '' : urlConfig.pass) || textOf(fileSmtp.pass))
+    : ((urlConfig === null ? '' : urlConfig.pass) || passFromFile)
 
   const setupHint = '请通过环境变量 ' + FEEDBACK_ENV.to + ' / ' + FEEDBACK_ENV.host
     + '（或复用 ' + FEEDBACK_ENV.smtpUrl + '）配置'
@@ -390,7 +451,8 @@ export function feedbackConfigFrom(options = {}) {
   }
 
   if (to === '') return { ok: false, message: '尚未配置反馈收件邮箱。' + setupHint + '。' }
-  if (!EMAIL_RE.test(to)) return { ok: false, message: '反馈收件邮箱格式不正确，请检查收件人配置' }
+  const toVerdict = mailboxVerdict(to)
+  if (toVerdict !== '') return { ok: false, message: '反馈收件邮箱' + toVerdict + '，请检查收件人配置' }
   if (host === '') return { ok: false, message: '尚未配置 SMTP 服务器。' + setupHint + '。' }
 
   const secure = boolOf(secureText, false)
@@ -405,9 +467,10 @@ export function feedbackConfigFrom(options = {}) {
 
   // A From is required by SMTP. It does not have to be an alias the server
   // accepts (that is the server's policy), but it must be one mailbox.
-  const fromAddress = from !== '' ? from : (user !== '' && EMAIL_RE.test(user) ? user : to)
-  if (!EMAIL_RE.test(fromAddress)) {
-    return { ok: false, message: '反馈发件邮箱格式不正确，请检查 FROM 配置' }
+  const fromAddress = from !== '' ? from : (user !== '' && isMailbox(user) ? user : to)
+  const fromVerdict = mailboxVerdict(fromAddress)
+  if (fromVerdict !== '') {
+    return { ok: false, message: '反馈发件邮箱' + fromVerdict + '，请检查 FROM 配置' }
   }
   if (user === '' && pass !== '') {
     return { ok: false, message: '已配置 SMTP 密码但缺少 SMTP 用户名（' + FEEDBACK_ENV.user + '）' }
@@ -489,7 +552,7 @@ export function buildFeedbackMessage(options = {}) {
     messageId: randomUUID() + '@' + messageDomain(options.from),
     // Only a bare, valid address becomes Reply-To. Free-form contact text must
     // never reach a header: a newline there would inject a header.
-    replyTo: EMAIL_RE.test(contact) ? contact : '',
+    replyTo: isMailbox(contact) ? contact : '',
   }
 }
 
@@ -503,24 +566,51 @@ function messageDomain(from) {
 }
 
 const b64 = (value) => Buffer.from(String(value), 'utf8').toString('base64')
-const encodeWord = (value) => '=?UTF-8?B?' + b64(oneLine(value)) + '?='
+/**
+ * RFC 2047: one encoded word may not exceed 75 characters, so a long subject is
+ * split into several. The payload is capped at 45 bytes (60 base64 characters +
+ * the 12-character wrapper = 72) and a multi-byte character never straddles two
+ * words.
+ */
+const ENCODED_WORD_PAYLOAD_BYTES = 45
+function encodeWords(value) {
+  const text = oneLine(value)
+  if (text === '') return '=?UTF-8?B??='
+  const words = []
+  let chunk = ''
+  let bytes = 0
+  for (const char of text) {
+    const size = Buffer.byteLength(char, 'utf8')
+    if (bytes + size > ENCODED_WORD_PAYLOAD_BYTES && chunk !== '') {
+      words.push('=?UTF-8?B?' + b64(chunk) + '?=')
+      chunk = ''
+      bytes = 0
+    }
+    chunk += char
+    bytes += size
+  }
+  if (chunk !== '') words.push('=?UTF-8?B?' + b64(chunk) + '?=')
+  return words.join(' ')
+}
 
 /** RFC 5322 headers + base64 body. Base64 never needs dot-stuffing. */
 export function buildRawMail(options = {}) {
-  const from = textOf(options.from)
-  const to = textOf(options.to)
+  // The envelope addresses reach the headers verbatim, so this formatter refuses
+  // a newline or a control byte itself instead of trusting every caller.
+  const from = assertHeaderSafe(textOf(options.from), '发件邮箱')
+  const to = assertHeaderSafe(textOf(options.to), '收件邮箱')
   const now = options.now instanceof Date ? options.now : new Date()
   const messageId = textOf(options.messageId) || (randomUUID() + '@' + messageDomain(from))
   const subject = oneLine(options.subject)
   const replyTo = oneLine(options.replyTo)
   const body64 = b64(options.text).replace(/(.{76})/g, '$1\r\n')
   const headers = [
-    'From: ' + encodeWord('DSH 指令记忆反馈') + ' <' + from + '>',
+    'From: ' + encodeWords('DSH 指令记忆反馈') + ' <' + from + '>',
     'To: <' + to + '>',
   ]
-  if (EMAIL_RE.test(replyTo)) headers.push('Reply-To: <' + replyTo + '>')
+  if (isMailbox(replyTo)) headers.push('Reply-To: <' + replyTo + '>')
   headers.push(
-    'Subject: ' + encodeWord(subject),
+    'Subject: ' + encodeWords(subject),
     'Date: ' + now.toUTCString(),
     'Message-ID: <' + messageId + '>',
     'MIME-Version: 1.0',
@@ -546,6 +636,13 @@ function createChannel(socket, timeoutMs) {
   }
   const onData = (chunk) => {
     state.buffer += chunk.toString('utf8')
+    // A peer that keeps sending bytes without CRLF must not be able to grow this
+    // buffer without bound; every other read is line-delimited and small.
+    if (state.buffer.length > MAX_RESPONSE_BYTES) {
+      fail(new Error('SMTP 响应过长（超过 ' + MAX_RESPONSE_BYTES + ' 字节），已断开连接'))
+      socket.destroy()
+      return
+    }
     for (;;) {
       const index = state.buffer.indexOf('\r\n')
       if (index === -1) return
@@ -617,7 +714,7 @@ function createChannel(socket, timeoutMs) {
     socket.on('error', () => {})
   }
 
-  return { readResponse, write, dispose }
+  return { readResponse, write, dispose, fail }
 }
 
 const smtpError = (what, response) =>
@@ -641,10 +738,23 @@ async function hello(channel, name) {
   return response.lines.map((line) => line.trim())
 }
 
+/**
+ * The AUTH mechanisms a server actually offers. Only the AUTH capability line
+ * counts (RFC 4954); matching the bare word anywhere in the EHLO reply used to
+ * pick LOGIN whenever an unrelated extension happened to contain "LOGIN"
+ * (e.g. X-LOGIN-POLICY). Exported so the suite can pin that down.
+ */
+export function smtpAuthMechanisms(caps) {
+  const list = Array.isArray(caps) ? caps : []
+  const authLine = list.find((cap) => typeof cap === 'string' && /^AUTH[= ]/i.test(cap))
+  if (authLine === undefined) return []
+  return authLine.replace(/^AUTH[= ]+/i, '').toUpperCase().split(/[\s,]+/).filter((name) => name !== '')
+}
+
 async function authenticate(channel, smtp, caps) {
-  const capabilityText = caps.join(' ').toUpperCase()
-  const canLogin = /\bLOGIN\b/.test(capabilityText)
-  const canPlain = /\bPLAIN\b/.test(capabilityText)
+  const mechanisms = smtpAuthMechanisms(caps)
+  const canLogin = mechanisms.includes('LOGIN')
+  const canPlain = mechanisms.includes('PLAIN')
   const fail = (response) => new Error('SMTP 认证失败（' + response.code + '）：'
     + cutText(response.lines.join(' '), 300)
     + '。请检查用户名 / 密码；Gmail、QQ 邮箱等服务需要「应用专用密码」，不能用登录密码。')
@@ -721,6 +831,10 @@ export async function sendSmtpMail(options = {}) {
     throw new Error('SMTP 配置不完整（host / port）')
   }
   if (from === '' || to === '') throw new Error('SMTP 配置不完整（from / to）')
+  const fromVerdict = mailboxVerdict(from)
+  if (fromVerdict !== '') throw new Error('发件邮箱' + fromVerdict)
+  const toVerdict = mailboxVerdict(to)
+  if (toVerdict !== '') throw new Error('收件邮箱' + toVerdict)
 
   const mail = buildRawMail({
     from,
@@ -736,6 +850,13 @@ export async function sendSmtpMail(options = {}) {
 
   let socket = await openSocket({ host, port, secure: smtp.secure === true }, timeoutMs)
   let channel = createChannel(socket, timeoutMs)
+  // Overall ceiling: the per-step idle timeout may be paid several times over
+  // (greeting, EHLO, STARTTLS, AUTH, DATA), which would outlast the panel's own
+  // timeout and show "timed out" for a mail that is still on its way.
+  const overallTimer = setTimeout(() => {
+    channel.fail(new Error('SMTP 总耗时超过 ' + SMTP_TOTAL_TIMEOUT_MS + ' ms，已中止发送'))
+    socket.destroy()
+  }, SMTP_TOTAL_TIMEOUT_MS)
   try {
     await expectCode(channel, 220, '服务端欢迎')
     let caps = await hello(channel, clientName)
@@ -770,6 +891,7 @@ export async function sendSmtpMail(options = {}) {
     }
     return { messageId: mail.messageId, accepted: to, response: accepted.lines.join(' ') }
   } finally {
+    clearTimeout(overallTimer)
     channel.dispose()
     // Add an error listener before destroy: a socket destroyed mid-TLS can emit
     // ECONNRESET synchronously, and an unhandled 'error' would take the host down.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-instruction-memory",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "User-only instruction memory for DSH: long-term instructions maintained in the settings UI and auto-injected into every conversation — the model has no write access. 指令记忆：只由用户在设置页维护的长期指令，自动注入此后每轮对话；模型没有任何写入口。",
   "license": "MIT",
   "type": "module",
@@ -59,7 +59,8 @@
   "scripts": {
     "lint": "node lint.mjs",
     "test": "node lint.mjs && node host-range-test.mjs && node smoke-test.mjs && node contract-test.mjs && node verify.mjs && node feedback-test.mjs && node ui-test.mjs",
-    "prepublishOnly": "node check-metadata.mjs"
+    "prepublishOnly": "node check-metadata.mjs && npm test",
+    "smoke:hosts": "node live-host-smoke.mjs"
   },
   "dsh": {
     "bundle": {