wpy/wpywmail
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: WpywMail 自建邮件系统：.NET 8 原生 SMTP/IMAP 服务端（DKIM 签名、SPF/DKIM/DMARC 入站校验、SQLite 存储、完整账号体系）、Node 服务端、WinUI 3 客户端与 Web 前端

Browse Source
This commit is contained in:
WpyQwq
2026-09-19 11:19:40 +08:00
commit b8814a7615
84 changed files with 21197 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server-native/DirectSmtpDelivery.cs
+317
View File
@@ -0,0 +1,317 @@
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Text;
namespace WpywMail.Native;
public sealed class DirectSmtpDelivery
{
private readonly AppConfig config;
private readonly FileStore store;
public DirectSmtpDelivery(AppConfig config, FileStore store)
{
this.config = config;
this.store = store;
}
public async Task DeliverAsync(MailMessage message, string[] recipients, CancellationToken token)
{
if (recipients.Length == 0) throw new InvalidOperationException("没有可投递的收件人。");
var raw = store.ReadRaw(message.RawPath);
foreach (var group in recipients.Where(IsValidAddress).GroupBy(GetDomain, StringComparer.OrdinalIgnoreCase))
{
await DeliverDomainAsync(message.From, group.Key, group.ToArray(), raw, token);
}
}
private async Task DeliverDomainAsync(string sender, string domain, string[] recipients, byte[] raw, CancellationToken token)
{
var mxHosts = await MxResolver.ResolveAsync(domain, config.DirectDelivery, token);
if (mxHosts.Count == 0) throw new InvalidOperationException($"找不到 {domain} 的 MX 记录。");
Exception? last = null;
foreach (var mxHost in mxHosts)
{
try
{
await SendToMxAsync(mxHost, sender, recipients, raw, token, tryStartTls: true);
return;
}
catch (StartTlsUnavailableException) when (!config.DirectDelivery.RequireStartTls)
{
try
{
await SendToMxAsync(mxHost, sender, recipients, raw, token, tryStartTls: false);
return;
}
catch (Exception ex) when (ex is IOException or SocketException or TimeoutException or InvalidOperationException or AuthenticationException)
{
last = ex;
AppLog.Warn($"[发送] MX {mxHost} 明文重试失败：{ex.Message}");
}
}
catch (Exception ex) when (ex is IOException or SocketException or TimeoutException or InvalidOperationException or AuthenticationException)
{
last = ex;
AppLog.Warn($"[发送] MX {mxHost} 失败：{ex.Message}");
}
}
throw new InvalidOperationException($"无法投递到 {domain}：{last?.Message ?? "所有 MX 服务器均失败"}");
}
private async Task SendToMxAsync(string mxHost, string sender, string[] recipients, byte[] raw, CancellationToken token, bool tryStartTls)
{
using var client = new TcpClient { NoDelay = true };
await client.ConnectAsync(mxHost, 25, token).AsTask().WaitAsync(TimeSpan.FromSeconds(config.DirectDelivery.ConnectionTimeoutSeconds), token);
Stream stream = client.GetStream();
StreamReader reader = NewReader(stream);
StreamWriter writer = NewWriter(stream);
try
{
Expect(await ReadReplyAsync(reader, token), "连接欢迎语", 220);
var hello = await CommandAsync(reader, writer, $"EHLO {config.Hostname}", token);
if (hello.Code < 200 || hello.Code >= 300)
{
Expect(await CommandAsync(reader, writer, $"HELO {config.Hostname}", token), "HELO", 250);
}
else if (tryStartTls && config.DirectDelivery.OpportunisticStartTls && HasCapability(hello, "STARTTLS"))
{
var startTls = await CommandAsync(reader, writer, "STARTTLS", token);
if (startTls.Code == 220)
{
try
{
var ssl = new SslStream(stream, leaveInnerStreamOpen: false, ValidateCertificate);
await ssl.AuthenticateAsClientAsync(new SslClientAuthenticationOptions
{
TargetHost = mxHost,
EnabledSslProtocols = SslProtocols.Tls12 | SslProtocols.Tls13
}, token).WaitAsync(TimeSpan.FromSeconds(config.DirectDelivery.CommandTimeoutSeconds), token);
stream = ssl;
reader = NewReader(stream);
writer = NewWriter(stream);
hello = await CommandAsync(reader, writer, $"EHLO {config.Hostname}", token);
}
catch (AuthenticationException) when (!config.DirectDelivery.RequireStartTls)
{
throw new StartTlsUnavailableException("对方 STARTTLS 证书验证失败。");
}
}
else if (config.DirectDelivery.RequireStartTls)
{
throw new InvalidOperationException("对方 SMTP 不接受 STARTTLS。");
}
}
else if (config.DirectDelivery.RequireStartTls)
{
throw new InvalidOperationException("对方 SMTP 未提供 STARTTLS。");
}
Expect(await CommandAsync(reader, writer, $"MAIL FROM:<{NormalizeAddress(sender)}>", token), "MAIL FROM", 250);
foreach (var recipient in recipients)
{
Expect(await CommandAsync(reader, writer, $"RCPT TO:<{NormalizeAddress(recipient)}>", token), $"RCPT TO {recipient}", 250, 251);
}
Expect(await CommandAsync(reader, writer, "DATA", token), "DATA", 354);
await WriteDataAsync(writer, raw, token);
Expect(await ReadReplyAsync(reader, token), "邮件正文", 250);
await TryQuitAsync(reader, writer, token);
}
finally
{
await stream.DisposeAsync();
}
}
private async Task WriteDataAsync(StreamWriter writer, byte[] raw, CancellationToken token)
{
var text = Encoding.UTF8.GetString(raw).Replace("\r\n", "\n").Replace('\r', '\n');
var lines = text.Split('\n');
for (var index = 0; index < lines.Length; index++)
{
if (index == lines.Length - 1 && lines[index].Length == 0) continue;
var line = lines[index];
if (line.StartsWith('.')) line = "." + line;
await writer.WriteLineAsync(line).WaitAsync(TimeSpan.FromSeconds(config.DirectDelivery.CommandTimeoutSeconds), token);
}
await writer.WriteLineAsync(".").WaitAsync(TimeSpan.FromSeconds(config.DirectDelivery.CommandTimeoutSeconds), token);
}
private async Task<SmtpReply> CommandAsync(StreamReader reader, StreamWriter writer, string command, CancellationToken token)
{
await writer.WriteLineAsync(command).WaitAsync(TimeSpan.FromSeconds(config.DirectDelivery.CommandTimeoutSeconds), token);
return await ReadReplyAsync(reader, token);
}
private async Task<SmtpReply> ReadReplyAsync(StreamReader reader, CancellationToken token)
{
var lines = new List<string>();
var first = await reader.ReadLineAsync(token).AsTask().WaitAsync(TimeSpan.FromSeconds(config.DirectDelivery.CommandTimeoutSeconds), token)
?? throw new IOException("SMTP 连接提前关闭。");
lines.Add(first);
if (first.Length < 3 || !int.TryParse(first[..3], out var code)) throw new InvalidOperationException($"SMTP 返回无效响应：{first}");
if (first.Length > 3 && first[3] == '-')
{
while (true)
{
var line = await reader.ReadLineAsync(token).AsTask().WaitAsync(TimeSpan.FromSeconds(config.DirectDelivery.CommandTimeoutSeconds), token)
?? throw new IOException("SMTP 多行响应提前结束。");
lines.Add(line);
if (line.StartsWith($"{code:D3} ", StringComparison.Ordinal)) break;
}
}
return new SmtpReply(code, lines);
}
private static bool HasCapability(SmtpReply reply, string capability) =>
reply.Lines.Any(x => x.Length > 4 && x[4..].StartsWith(capability, StringComparison.OrdinalIgnoreCase));
private static void Expect(SmtpReply reply, string step, params int[] expected)
{
if (!expected.Contains(reply.Code)) throw new SmtpDeliveryException(step, reply.Code, reply.Lines.LastOrDefault() ?? "");
}
private static async Task TryQuitAsync(StreamReader reader, StreamWriter writer, CancellationToken token)
{
try
{
await writer.WriteLineAsync("QUIT").WaitAsync(TimeSpan.FromSeconds(5), token);
await reader.ReadLineAsync(token).AsTask().WaitAsync(TimeSpan.FromSeconds(5), token);
}
catch { }
}
private static StreamReader NewReader(Stream stream) => new(stream, Encoding.ASCII, false, 8192, true);
private static StreamWriter NewWriter(Stream stream) => new(stream, Encoding.ASCII, 8192, true) { AutoFlush = true, NewLine = "\r\n" };
private static bool ValidateCertificate(object sender, System.Security.Cryptography.X509Certificates.X509Certificate? certificate, System.Security.Cryptography.X509Certificates.X509Chain? chain, SslPolicyErrors errors) => errors == SslPolicyErrors.None;
private static bool IsValidAddress(string value) => value.Contains('@') && value.IndexOf('@') > 0 && value.IndexOf('@') < value.Length - 1;
private static string GetDomain(string value) => value[(value.LastIndexOf('@') + 1)..].Trim().TrimEnd('.').ToLowerInvariant();
private static string NormalizeAddress(string value) => value.Trim().Trim('<', '>');
private sealed record SmtpReply(int Code, IReadOnlyList<string> Lines);
private sealed class StartTlsUnavailableException(string message) : Exception(message);
}
public sealed class SmtpDeliveryException(string step, int code, string detail) : Exception($"{step} 失败：{code} {detail}")
{
public int Code { get; } = code;
public bool Permanent => Code >= 500 && Code <= 599;
}
internal static class MxResolver
{
public static async Task<IReadOnlyList<string>> ResolveAsync(string domain, DirectDeliveryConfig config, CancellationToken token)
{
var servers = GetDnsServers(config.DnsServer);
foreach (var server in servers)
{
try
{
var records = await QueryAsync(domain, server, config.DnsTimeoutSeconds, token);
if (records.Count > 0) return records;
}
catch (Exception ex) when (ex is SocketException or TimeoutException or InvalidOperationException)
{
AppLog.Warn($"[DNS] 查询 {domain} 的 MX 失败（{server}）：{ex.Message}");
}
}
try
{
var addresses = await Dns.GetHostAddressesAsync(domain, token);
return addresses.Select(x => x.ToString()).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
}
catch { return []; }
}
private static async Task<IReadOnlyList<string>> QueryAsync(string domain, IPAddress server, int timeoutSeconds, CancellationToken token)
{
using var udp = new UdpClient(server.AddressFamily);
var query = BuildQuery(domain, out var id);
await udp.SendAsync(query, query.Length, new IPEndPoint(server, 53));
var result = await udp.ReceiveAsync().WaitAsync(TimeSpan.FromSeconds(Math.Max(1, timeoutSeconds)), token);
return ParseResponse(result.Buffer, id);
}
private static byte[] BuildQuery(string domain, out ushort id)
{
id = (ushort)Random.Shared.Next(1, ushort.MaxValue);
using var stream = new MemoryStream();
using var writer = new BinaryWriter(stream, Encoding.ASCII, leaveOpen: true);
writer.Write(ToNetwork(id)); writer.Write(ToNetwork((ushort)0x0100)); writer.Write(ToNetwork((ushort)1)); writer.Write(ToNetwork((ushort)0)); writer.Write(ToNetwork((ushort)0)); writer.Write(ToNetwork((ushort)0));
foreach (var label in domain.TrimEnd('.').Split('.', StringSplitOptions.RemoveEmptyEntries))
{
var bytes = Encoding.ASCII.GetBytes(label);
writer.Write((byte)bytes.Length); writer.Write(bytes);
}
writer.Write((byte)0); writer.Write(ToNetwork((ushort)15)); writer.Write(ToNetwork((ushort)1));
return stream.ToArray();
}
private static IReadOnlyList<string> ParseResponse(byte[] data, ushort expectedId)
{
if (data.Length < 12 || ReadUInt16(data, 0) != expectedId) return [];
var flags = ReadUInt16(data, 2);
if ((flags & 0x8000) == 0 || (flags & 0x000F) != 0) return [];
var questions = ReadUInt16(data, 4); var answers = ReadUInt16(data, 6); var authority = ReadUInt16(data, 8); var additional = ReadUInt16(data, 10);
var offset = 12;
for (var i = 0; i < questions; i++) { ReadName(data, ref offset); offset += 4; }
var records = new List<(ushort Preference, string Host)>();
for (var i = 0; i < answers + authority + additional && offset < data.Length; i++)
{
ReadName(data, ref offset);
if (offset + 10 > data.Length) break;
var type = ReadUInt16(data, offset); var cls = ReadUInt16(data, offset + 2); var length = ReadUInt16(data, offset + 8); offset += 10;
if (offset + length > data.Length) break;
if (type == 15 && cls == 1 && length >= 3)
{
var preference = ReadUInt16(data, offset); var nameOffset = offset + 2; var host = ReadName(data, ref nameOffset);
if (!string.IsNullOrWhiteSpace(host)) records.Add((preference, host.TrimEnd('.')));
}
offset += length;
}
return records.OrderBy(x => x.Preference).Select(x => x.Host).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
}
private static string ReadName(byte[] data, ref int offset)
{
var labels = new List<string>(); var cursor = offset; var jumped = false; var next = offset;
while (cursor < data.Length)
{
var length = data[cursor++];
if (length == 0) { if (!jumped) next = cursor; break; }
if ((length & 0xC0) == 0xC0)
{
if (cursor >= data.Length) throw new InvalidOperationException("DNS 名称指针无效。");
var pointer = ((length & 0x3F) << 8) | data[cursor++];
if (!jumped) next = cursor; cursor = pointer; jumped = true; continue;
}
if (length > 63 || cursor + length > data.Length) throw new InvalidOperationException("DNS 名称长度无效。");
labels.Add(Encoding.ASCII.GetString(data, cursor, length)); cursor += length;
}
offset = next;
return string.Join('.', labels);
}
private static ushort ReadUInt16(byte[] data, int offset) => (ushort)((data[offset] << 8) | data[offset + 1]);
private static ushort ToNetwork(ushort value) => (ushort)((value << 8) | (value >> 8));
private static IReadOnlyList<IPAddress> GetDnsServers(string configured)
{
if (IPAddress.TryParse(configured, out var parsed)) return [parsed];
var system = NetworkInterface.GetAllNetworkInterfaces()
.Where(x => x.OperationalStatus == OperationalStatus.Up)
.SelectMany(x => x.GetIPProperties().DnsAddresses)
.Where(x => x.AddressFamily == AddressFamily.InterNetwork || (x.AddressFamily == AddressFamily.InterNetworkV6 && !x.IsIPv6SiteLocal))
.Distinct()
.OrderBy(x => x.AddressFamily == AddressFamily.InterNetwork ? 0 : 1)
.ToArray();
return system.Length > 0 ? system : [IPAddress.Parse("223.5.5.5"), IPAddress.Parse("1.1.1.1")];
}
}