mailcatcher-ng 1.0.0

data/lib/mail_catcher/mail.rb

@@ -0,0 +1,419 @@
+# frozen_string_literal: true
+
+require "eventmachine"
+require "json"
+require "mail"
+require "sqlite3"
+
+module MailCatcher::Mail extend self
+  def db
+    @__db ||= begin
+      SQLite3::Database.new(":memory:", :type_translation => true).tap do |db|
+        db.execute(<<-SQL)
+          CREATE TABLE message (
+            id INTEGER PRIMARY KEY ASC,
+            sender TEXT,
+            recipients TEXT,
+            subject TEXT,
+            source BLOB,
+            size TEXT,
+            type TEXT,
+            created_at DATETIME DEFAULT CURRENT_DATETIME
+          )
+        SQL
+        db.execute(<<-SQL)
+          CREATE TABLE message_part (
+            id INTEGER PRIMARY KEY ASC,
+            message_id INTEGER NOT NULL,
+            cid TEXT,
+            type TEXT,
+            is_attachment INTEGER,
+            filename TEXT,
+            charset TEXT,
+            body BLOB,
+            size INTEGER,
+            created_at DATETIME DEFAULT CURRENT_DATETIME,
+            FOREIGN KEY (message_id) REFERENCES message (id) ON DELETE CASCADE
+          )
+        SQL
+        db.execute("PRAGMA foreign_keys = ON")
+      end
+    end
+  end
+
+  def add_message(message)
+    @add_message_query ||= db.prepare("INSERT INTO message (sender, recipients, subject, source, type, size, created_at) VALUES (?, ?, ?, ?, ?, ?, datetime('now'))")
+
+    mail = Mail.new(message[:source])
+    @add_message_query.execute(message[:sender], JSON.generate(message[:recipients]), mail.subject, message[:source], mail.mime_type || "text/plain", message[:source].length)
+    message_id = db.last_insert_row_id
+    parts = mail.all_parts
+    parts = [mail] if parts.empty?
+    parts.each do |part|
+      body = part.body.to_s
+      # Only parts have CIDs, not mail
+      cid = part.cid if part.respond_to? :cid
+      add_message_part(message_id, cid, part.mime_type || "text/plain", part.attachment? ? 1 : 0, part.filename, part.charset, body, body.length)
+    end
+
+    EventMachine.next_tick do
+      message = MailCatcher::Mail.message message_id
+      MailCatcher::Bus.push(type: "add", message: message)
+    end
+  end
+
+  def add_message_part(*args)
+    @add_message_part_query ||= db.prepare "INSERT INTO message_part (message_id, cid, type, is_attachment, filename, charset, body, size, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))"
+    @add_message_part_query.execute(*args)
+  end
+
+  def latest_created_at
+    @latest_created_at_query ||= db.prepare "SELECT created_at FROM message ORDER BY created_at DESC LIMIT 1"
+    @latest_created_at_query.execute.next
+  end
+
+  def messages
+    @messages_query ||= db.prepare "SELECT id, sender, recipients, subject, size, created_at FROM message ORDER BY created_at, id ASC"
+    @messages_query.execute.map do |row|
+      Hash[@messages_query.columns.zip(row)].tap do |message|
+        message["recipients"] &&= JSON.parse(message["recipients"])
+      end
+    end
+  end
+
+  def message(id)
+    @message_query ||= db.prepare "SELECT id, sender, recipients, subject, size, type, created_at FROM message WHERE id = ? LIMIT 1"
+    row = @message_query.execute(id).next
+    row && Hash[@message_query.columns.zip(row)].tap do |message|
+      message["recipients"] &&= JSON.parse(message["recipients"])
+    end
+  end
+
+  def message_source(id)
+    @message_source_query ||= db.prepare "SELECT source FROM message WHERE id = ? LIMIT 1"
+    row = @message_source_query.execute(id).next
+    row && row.first
+  end
+
+  def message_bimi_location(id)
+    source = message_source(id)
+    return nil unless source
+
+    # Extract BIMI-Location header from email source
+    # Headers are case-insensitive
+    source.each_line do |line|
+      # Stop at first blank line (end of headers)
+      break if line.strip.empty?
+      # Match BIMI-Location header (case-insensitive)
+      if line.match?(/^bimi-location:\s*/i)
+        # Extract the value and clean it up
+        value = line.sub(/^bimi-location:\s*/i, '').strip
+        return value unless value.empty?
+      end
+    end
+
+    nil
+  end
+
+  def message_preview_text(id)
+    source = message_source(id)
+    return nil unless source
+
+    # Extract Preview-Text header from email source (tier 1 of preview text extraction)
+    # This is a de facto standard header (not formal RFC) used by email clients
+    # to display preview/preheader text in the inbox preview pane
+    source.each_line do |line|
+      # Stop at first blank line (end of headers)
+      break if line.strip.empty?
+      # Match Preview-Text header (case-insensitive)
+      if line.match?(/^preview-text:\s*/i)
+        # Extract the value and clean it up
+        value = line.sub(/^preview-text:\s*/i, '').strip
+        return value unless value.empty?
+      end
+    end
+
+    nil
+  end
+
+  def message_from(id)
+    source = message_source(id)
+    return nil unless source
+
+    # Extract From header from email source
+    source.each_line do |line|
+      # Stop at first blank line (end of headers)
+      break if line.strip.empty?
+      # Match From header (case-insensitive)
+      if line.match?(/^from:\s*/i)
+        # Extract the value and handle multi-line headers
+        value = line.sub(/^from:\s*/i, '').strip
+
+        # Continue reading continuation lines (lines starting with whitespace)
+        lines = source.lines
+        line_index = lines.index { |l| l.match?(/^from:\s*/i) }
+        next_index = line_index + 1 if line_index
+        while next_index && next_index < lines.length && lines[next_index].match?(/^\s+/)
+          value += " " + lines[next_index].strip
+          next_index += 1
+        end
+
+        return value unless value.empty?
+      end
+    end
+
+    nil
+  end
+
+  def message_to(id)
+    source = message_source(id)
+    return nil unless source
+
+    # Extract To header from email source
+    source.each_line do |line|
+      # Stop at first blank line (end of headers)
+      break if line.strip.empty?
+      # Match To header (case-insensitive)
+      if line.match?(/^to:\s*/i)
+        # Extract the value and handle multi-line headers
+        value = line.sub(/^to:\s*/i, '').strip
+
+        # Continue reading continuation lines (lines starting with whitespace)
+        lines = source.lines
+        line_index = lines.index { |l| l.match?(/^to:\s*/i) }
+        next_index = line_index + 1 if line_index
+        while next_index && next_index < lines.length && lines[next_index].match?(/^\s+/)
+          value += " " + lines[next_index].strip
+          next_index += 1
+        end
+
+        return value unless value.empty?
+      end
+    end
+
+    nil
+  end
+
+  def message_authentication_results(id)
+    source = message_source(id)
+    return {} unless source
+
+    auth_results = {
+      dmarc: nil,
+      dkim: nil,
+      spf: nil
+    }
+
+    lines = source.lines
+    lines.each_with_index do |line, index|
+      break if line.strip.empty?
+
+      # Authentication-Results header contains DMARC, DKIM, and SPF info
+      if line.match?(/^authentication-results:\s*/i)
+        # Extract the value and handle multi-line headers
+        value = line.sub(/^authentication-results:\s*/i, '').strip
+
+        # Continue reading continuation lines (lines starting with whitespace)
+        next_index = index + 1
+        while next_index < lines.length && lines[next_index].match?(/^\s+/)
+          value += " " + lines[next_index].strip
+          next_index += 1
+        end
+
+        auth_results = parse_authentication_results(value)
+        break
+      end
+    end
+
+    auth_results
+  end
+
+  def message_has_html?(id)
+    @message_has_html_query ||= db.prepare "SELECT 1 FROM message_part WHERE message_id = ? AND is_attachment = 0 AND type IN ('application/xhtml+xml', 'text/html') LIMIT 1"
+    (!!@message_has_html_query.execute(id).next) || ["text/html", "application/xhtml+xml"].include?(message(id)["type"])
+  end
+
+  def message_has_plain?(id)
+    @message_has_plain_query ||= db.prepare "SELECT 1 FROM message_part WHERE message_id = ? AND is_attachment = 0 AND type = 'text/plain' LIMIT 1"
+    (!!@message_has_plain_query.execute(id).next) || message(id)["type"] == "text/plain"
+  end
+
+  def message_parts(id)
+    @message_parts_query ||= db.prepare "SELECT cid, type, filename, size FROM message_part WHERE message_id = ? ORDER BY filename ASC"
+    @message_parts_query.execute(id).map do |row|
+      Hash[@message_parts_query.columns.zip(row)]
+    end
+  end
+
+  def message_attachments(id)
+    @message_attachments_query ||= db.prepare "SELECT cid, type, filename, size FROM message_part WHERE message_id = ? AND is_attachment = 1 ORDER BY filename ASC"
+    @message_attachments_query.execute(id).map do |row|
+      Hash[@message_attachments_query.columns.zip(row)]
+    end
+  end
+
+  def message_part(message_id, part_id)
+    @message_part_query ||= db.prepare "SELECT * FROM message_part WHERE message_id = ? AND id = ? LIMIT 1"
+    row = @message_part_query.execute(message_id, part_id).next
+    row && Hash[@message_part_query.columns.zip(row)]
+  end
+
+  def message_part_type(message_id, part_type)
+    @message_part_type_query ||= db.prepare "SELECT * FROM message_part WHERE message_id = ? AND type = ? AND is_attachment = 0 LIMIT 1"
+    row = @message_part_type_query.execute(message_id, part_type).next
+    row && Hash[@message_part_type_query.columns.zip(row)]
+  end
+
+  def message_part_html(message_id)
+    part = message_part_type(message_id, "text/html")
+    part ||= message_part_type(message_id, "application/xhtml+xml")
+    part ||= begin
+      message = message(message_id)
+      message if message and ["text/html", "application/xhtml+xml"].include? message["type"]
+    end
+  end
+
+  def message_part_plain(message_id)
+    message_part_type message_id, "text/plain"
+  end
+
+  def message_part_cid(message_id, cid)
+    @message_part_cid_query ||= db.prepare "SELECT * FROM message_part WHERE message_id = ?"
+    @message_part_cid_query.execute(message_id).map do |row|
+      Hash[@message_part_cid_query.columns.zip(row)]
+    end.find do |part|
+      part["cid"] == cid
+    end
+  end
+
+  def delete!
+    @delete_all_messages_query ||= db.prepare "DELETE FROM message"
+    @delete_all_messages_query.execute
+
+    EventMachine.next_tick do
+      MailCatcher::Bus.push(type: "clear")
+    end
+  end
+
+  def delete_message!(message_id)
+    @delete_messages_query ||= db.prepare "DELETE FROM message WHERE id = ?"
+    @delete_messages_query.execute(message_id)
+
+    EventMachine.next_tick do
+      MailCatcher::Bus.push(type: "remove", id: message_id)
+    end
+  end
+
+  def delete_older_messages!(count = MailCatcher.options[:messages_limit])
+    return if count.nil?
+    @older_messages_query ||= db.prepare "SELECT id FROM message WHERE id NOT IN (SELECT id FROM message ORDER BY created_at DESC LIMIT ?)"
+    @older_messages_query.execute(count).map do |row|
+      Hash[@older_messages_query.columns.zip(row)]
+    end.each do |message|
+      delete_message!(message["id"])
+    end
+  end
+
+  def message_encryption_data(id)
+    source = message_source(id)
+    return {} unless source
+
+    encryption_data = {
+      smime: nil,
+      pgp: nil
+    }
+
+    lines = source.lines
+    lines.each_with_index do |line, index|
+      break if line.strip.empty?
+
+      # Check for S/MIME certificate headers
+      if line.match?(/^x-certificate:/i)
+        value = line.sub(/^x-certificate:\s*/i, '').strip
+        # Handle multi-line headers
+        next_index = index + 1
+        while next_index < lines.length && lines[next_index].match?(/^\s+/)
+          value += lines[next_index].strip
+          next_index += 1
+        end
+        encryption_data[:smime] = { certificate: value } if value.present?
+      end
+
+      # Check for S/MIME signature headers
+      if line.match?(/^x-smime-signature:/i)
+        value = line.sub(/^x-smime-signature:\s*/i, '').strip
+        # Handle multi-line headers
+        next_index = index + 1
+        while next_index < lines.length && lines[next_index].match?(/^\s+/)
+          value += lines[next_index].strip
+          next_index += 1
+        end
+        if encryption_data[:smime].nil?
+          encryption_data[:smime] = { signature: value }
+        else
+          encryption_data[:smime][:signature] = value
+        end
+      end
+
+      # Check for PGP key or signature headers
+      if line.match?(/^x-pgp-key:/i)
+        value = line.sub(/^x-pgp-key:\s*/i, '').strip
+        # Handle multi-line headers
+        next_index = index + 1
+        while next_index < lines.length && lines[next_index].match?(/^\s+/)
+          value += lines[next_index].strip
+          next_index += 1
+        end
+        encryption_data[:pgp] = { key: value } if value.present?
+      end
+
+      # Check for PGP signature headers
+      if line.match?(/^x-pgp-signature:/i)
+        value = line.sub(/^x-pgp-signature:\s*/i, '').strip
+        # Handle multi-line headers
+        next_index = index + 1
+        while next_index < lines.length && lines[next_index].match?(/^\s+/)
+          value += lines[next_index].strip
+          next_index += 1
+        end
+        if encryption_data[:pgp].nil?
+          encryption_data[:pgp] = { signature: value }
+        else
+          encryption_data[:pgp][:signature] = value
+        end
+      end
+    end
+
+    encryption_data
+  end
+
+  private
+
+  def parse_authentication_results(auth_header)
+    results = {
+      dmarc: nil,
+      dkim: nil,
+      spf: nil
+    }
+
+    # Parse DMARC result
+    if auth_header.match?(/dmarc=/i)
+      dmarc_match = auth_header.match(/dmarc=(\w+)/i)
+      results[:dmarc] = dmarc_match[1].downcase if dmarc_match
+    end
+
+    # Parse DKIM result
+    if auth_header.match?(/dkim=/i)
+      dkim_match = auth_header.match(/dkim=(\w+)/i)
+      results[:dkim] = dkim_match[1].downcase if dkim_match
+    end
+
+    # Parse SPF result
+    if auth_header.match?(/spf=/i)
+      spf_match = auth_header.match(/spf=(\w+)/i)
+      results[:spf] = spf_match[1].downcase if spf_match
+    end
+
+    results
+  end
+end

data/lib/mail_catcher/smtp.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "eventmachine"
+
+require "mail_catcher/mail"
+
+class MailCatcher::Smtp < EventMachine::Protocols::SmtpServer
+  # We override EM's mail from processing to allow multiple mail-from commands
+  # per [RFC 2821](https://tools.ietf.org/html/rfc2821#section-4.1.1.2)
+  def process_mail_from sender
+    if @state.include? :mail_from
+      @state -= [:mail_from, :rcpt, :data]
+
+      receive_reset
+    end
+
+    super
+  end
+
+  def current_message
+    @current_message ||= {}
+  end
+
+  def receive_reset
+    @current_message = nil
+
+    true
+  end
+
+  def receive_sender(sender)
+    # EventMachine SMTP advertises size extensions [https://tools.ietf.org/html/rfc1870]
+    # so strip potential " SIZE=..." suffixes from senders
+    sender = $` if sender =~ / SIZE=\d+\z/
+
+    current_message[:sender] = sender
+
+    true
+  end
+
+  def receive_recipient(recipient)
+    current_message[:recipients] ||= []
+    current_message[:recipients] << recipient
+
+    true
+  end
+
+  def receive_data_chunk(lines)
+    current_message[:source] ||= +""
+
+    lines.each do |line|
+      current_message[:source] << line << "\r\n"
+    end
+
+    true
+  end
+
+  def receive_message
+    MailCatcher::Mail.add_message current_message
+    MailCatcher::Mail.delete_older_messages!
+    puts "==> SMTP: Received message from '#{current_message[:sender]}' (#{current_message[:source].length} bytes)"
+    true
+  rescue => exception
+    MailCatcher.log_exception("Error receiving message", @current_message, exception)
+    false
+  ensure
+    @current_message = nil
+  end
+end

data/lib/mail_catcher/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MailCatcher
+  VERSION = '1.0.0'
+end