fix(channels/email)!: poll IMAP and accept only allowed, authenticated senders

The channel ran a hand-written SMTP listener and trusted the From address,
so anyone reaching the port could act as any user. It now uses go-imap,
go-message, go-msgauth and go-smtp; settings change accordingly.
This commit is contained in:
sam committed 2026-10-05 18:16:23 +11:00
1 parent da8436de6c
commit c4f9c3580c
5 files changed
+268 -246

No files matched your search

+196 -244
View File
@@ -1,300 +1,252 @@
// Command email is the email chat channel: it receives mail over SMTP, routes
// the body through the gateway, and replies through an SMTP relay. Settings:
// listen_addr (default :2525), relay_addr, relay_user, and relay_pass_ref
// ("engine:key" of the relay password).
// Command email is the email chat channel. It polls a mailbox over IMAP, routes
// mail from allowed, authenticated senders through the gateway, and replies
// over SMTP. Settings: imap_addr (host:993, implicit TLS), smtp_addr (host:587,
// STARTTLS), username, password_ref ("engine:key"), allowed_senders
// (comma-separated addresses), authserv_id (the mail provider's
// Authentication-Results id, such as "mx.google.com") and poll_interval
// (default 30s).
package main
import (
"bufio"
"context"
"crypto/tls"
"errors"
"fmt"
"io"
"log/slog"
"net"
"net/smtp"
"strings"
"time"
"github.com/emersion/go-imap/v2"
"github.com/emersion/go-imap/v2/imapclient"
"github.com/emersion/go-message/mail"
"github.com/emersion/go-msgauth/authres"
"github.com/emersion/go-sasl"
"github.com/emersion/go-smtp"
"github.com/samcharles93/archipelago/sdk/channel"
gatewayv1 "github.com/samcharles93/archipelago/sdk/gateway/v1"
)
type gateway struct {
chat gatewayv1.ChatServiceClient
relayAddr, relayUser, relayPass string
log *slog.Logger
type settings struct {
imapAddr, smtpAddr, username, password, authservID string
allowed map[string]bool
poll time.Duration
}
func main() { channel.Serve(run) }
func run(ctx context.Context, cfg channel.Config, chat gatewayv1.ChatServiceClient, lifecycle channel.Lifecycle) error {
lifecycle.Starting()
listen := cfg.Settings["listen_addr"]
if listen == "" {
listen = ":2525"
}
g := &gateway{
chat: chat,
relayAddr: cfg.Settings["relay_addr"],
relayUser: cfg.Settings["relay_user"],
relayPass: cfg.Secrets["relay_pass"],
log: slog.Default().With("component", "email"),
}
var lc net.ListenConfig
ln, err := lc.Listen(ctx, "tcp", listen)
s, err := parseSettings(cfg)
if err != nil {
return fmt.Errorf("email: listen %s: %w", listen, err)
return err
}
log := slog.Default().With("component", "email")
client, err := imapclient.DialTLS(s.imapAddr, nil)
if err != nil {
return fmt.Errorf("email: dial %s: %w", s.imapAddr, err)
}
defer client.Close()
if err := client.Login(s.username, s.password).Wait(); err != nil {
return fmt.Errorf("email: imap login: %w", err)
}
if _, err := client.Select("INBOX", nil).Wait(); err != nil {
return fmt.Errorf("email: select INBOX: %w", err)
}
g.log.Info("email channel listening", "addr", listen)
lifecycle.Running()
go func() {
<-ctx.Done()
_ = ln.Close()
}()
ticker := time.NewTicker(s.poll)
defer ticker.Stop()
for {
conn, err := ln.Accept()
if err != nil {
if ctx.Err() != nil || errors.Is(err, net.ErrClosed) {
return nil
}
g.log.Error("email accept", "err", err)
continue
// A failed poll ends the run; the host restarts the channel.
if err := poll(ctx, client, s, chat, log); err != nil {
return err
}
go g.handleSMTP(ctx, conn)
}
}
// handleSMTP processes one SMTP session.
func (g *gateway) handleSMTP(ctx context.Context, conn net.Conn) {
defer func() { _ = conn.Close() }()
r := bufio.NewReader(conn)
w := bufio.NewWriter(conn)
write := func(code int, msg string) {
_, _ = fmt.Fprintf(w, "%d %s\r\n", code, msg)
_ = w.Flush()
}
readLine := func() (string, error) {
line, err := r.ReadString('\n')
if err != nil {
return "", err
}
return strings.TrimRight(line, "\r\n"), nil
}
write(220, "archie email gateway ready")
var mailFrom, rcptTo string
var dataBuf strings.Builder
inData := false
for {
line, err := readLine()
if err != nil {
return
}
switch {
case inData:
if line == "." {
// End of DATA — process the message.
g.processMessage(ctx, mailFrom, rcptTo, dataBuf.String())
write(250, "OK: message accepted")
return
}
if strings.HasPrefix(line, "..") {
line = line[1:]
}
dataBuf.WriteString(line)
dataBuf.WriteString("\r\n")
case strings.HasPrefix(strings.ToUpper(line), "MAIL FROM:"):
mailFrom = extractAddr(line)
write(250, "OK")
case strings.HasPrefix(strings.ToUpper(line), "RCPT TO:"):
rcptTo = extractAddr(line)
write(250, "OK")
case strings.HasPrefix(strings.ToUpper(line), "DATA"):
write(354, "Start mail input; end with <CRLF>.<CRLF>")
inData = true
case strings.HasPrefix(strings.ToUpper(line), "QUIT"):
write(221, "Bye")
return
case strings.HasPrefix(strings.ToUpper(line), "EHLO"), strings.HasPrefix(strings.ToUpper(line), "HELO"):
write(250, "OK")
default:
write(500, "Unrecognized command")
select {
case <-ctx.Done():
_ = client.Logout().Wait()
return nil
case <-ticker.C:
}
}
}
// extractAddr pulls the email address from an SMTP command line like
// "MAIL FROM:<user@example.com>" or "RCPT TO:<user@example.com>".
func extractAddr(line string) string {
start := strings.IndexByte(line, '<')
end := strings.LastIndexByte(line, '>')
if start >= 0 && end > start {
return strings.TrimSpace(line[start+1 : end])
func parseSettings(cfg channel.Config) (settings, error) {
s := settings{
imapAddr: cfg.Settings["imap_addr"],
smtpAddr: cfg.Settings["smtp_addr"],
username: cfg.Settings["username"],
password: cfg.Secrets["password"],
authservID: cfg.Settings["authserv_id"],
allowed: map[string]bool{},
poll: 30 * time.Second,
}
return strings.TrimSpace(line)
for addr := range strings.SplitSeq(cfg.Settings["allowed_senders"], ",") {
if addr = strings.ToLower(strings.TrimSpace(addr)); addr != "" {
s.allowed[addr] = true
}
}
if v := cfg.Settings["poll_interval"]; v != "" {
d, err := time.ParseDuration(v)
if err != nil || d <= 0 {
return s, fmt.Errorf("email: poll_interval %q must be a positive duration", v)
}
s.poll = d
}
if s.imapAddr == "" || s.smtpAddr == "" || s.username == "" || s.password == "" || s.authservID == "" || len(s.allowed) == 0 {
return s, errors.New("email: imap_addr, smtp_addr, username, password_ref, authserv_id and allowed_senders are required")
}
return s, nil
}
// processMessage extracts text from the raw email and routes it through
// the messaging chat contract. Replies are sent back via SMTP.
func (g *gateway) processMessage(ctx context.Context, from, to, raw string) {
// Extract plain text body: everything after the first blank line
// following Content-Type or headers.
text := extractBody(raw)
// poll routes every unseen message once, marking each seen whether or not it
// was accepted so a rejected message is not reconsidered.
func poll(ctx context.Context, client *imapclient.Client, s settings, chat gatewayv1.ChatServiceClient, log *slog.Logger) error {
found, err := client.UIDSearch(&imap.SearchCriteria{NotFlag: []imap.Flag{imap.FlagSeen}}, nil).Wait()
if err != nil {
return fmt.Errorf("email: search: %w", err)
}
uids := found.AllUIDs()
if len(uids) == 0 {
return nil
}
section := &imap.FetchItemBodySection{Peek: true}
messages, err := client.Fetch(imap.UIDSetNum(uids...), &imap.FetchOptions{UID: true, BodySection: []*imap.FetchItemBodySection{section}}).Collect()
if err != nil {
return fmt.Errorf("email: fetch: %w", err)
}
for _, msg := range messages {
if err := handle(ctx, s, chat, msg.FindBodySection(section)); err != nil {
log.Warn("email message not routed", "uid", msg.UID, "err", err)
}
}
seen := &imap.StoreFlags{Op: imap.StoreFlagsAdd, Silent: true, Flags: []imap.Flag{imap.FlagSeen}}
if err := client.Store(imap.UIDSetNum(uids...), seen, nil).Close(); err != nil {
return fmt.Errorf("email: mark seen: %w", err)
}
return nil
}
// The channel names the platform it carries, which is how the gateway
// learns it is serving email.
reply, err := g.chat.Route(ctx, &gatewayv1.RouteRequest{Message: &gatewayv1.Message{
ChannelId: to,
From: from,
SenderId: from,
// handle routes one raw message and sends the reply.
func handle(ctx context.Context, s settings, chat gatewayv1.ChatServiceClient, raw []byte) error {
reader, err := mail.CreateReader(strings.NewReader(string(raw)))
if err != nil {
return fmt.Errorf("parse: %w", err)
}
from, err := reader.Header.AddressList("From")
if err != nil || len(from) != 1 {
return errors.New("message needs exactly one From address")
}
sender := strings.ToLower(from[0].Address)
if !s.allowed[sender] {
return fmt.Errorf("sender %q is not allowed", sender)
}
if !authenticated(reader.Header, s.authservID, sender) {
return fmt.Errorf("sender %q failed DMARC/DKIM at %s", sender, s.authservID)
}
text, err := plainText(reader)
if err != nil {
return err
}
reply, err := chat.Route(ctx, &gatewayv1.RouteRequest{Message: &gatewayv1.Message{
ChannelId: s.username,
From: sender,
SenderId: sender,
Text: text,
Platform: "email",
}})
if err != nil {
g.log.Error("email route", "err", err, "from", from)
return
return fmt.Errorf("route: %w", err)
}
if reply.GetText() != "" && g.relayAddr != "" {
if err := g.sendReply(from, to, reply.GetText()); err != nil {
g.log.Error("email reply", "err", err, "to", from)
}
if reply.GetText() == "" {
return nil
}
subject, _ := reader.Header.Subject()
messageID, _ := reader.Header.MessageID()
return sendReply(s, sender, subject, messageID, reply.GetText())
}
// extractBody pulls the plain text body from a raw email.
func extractBody(raw string) string {
// Find the message body: after headers (blank line).
parts := strings.SplitN(raw, "\r\n\r\n", 2)
if len(parts) < 2 {
parts = strings.SplitN(raw, "\n\n", 2)
}
if len(parts) < 2 {
return strings.TrimSpace(raw)
}
headers := parts[0]
body := parts[1]
// If multipart, look for the text/plain section.
if strings.Contains(strings.ToLower(headers), "content-type: multipart") {
if text := extractMultipartText(headers, body); text != "" {
return text
}
}
// Non-multipart: strip trailing SMTP dots.
return strings.TrimSpace(body)
}
// extractMultipartText looks for a text/plain section within a multipart
// body. Returns the trimmed text body or an empty string when not found.
func extractMultipartText(headers, body string) string {
idx := strings.Index(strings.ToLower(headers), "boundary=")
if idx < 0 {
return ""
}
boundary := extractBoundary(headers[idx:])
if boundary == "" {
return ""
}
sections := strings.SplitSeq(body, "--"+boundary)
for sec := range sections {
if !strings.Contains(strings.ToLower(sec), "content-type: text/plain") {
// authenticated reports whether the provider's own Authentication-Results
// header shows DMARC pass, or a DKIM pass signed by the From domain. Headers
// stamped by any other authserv-id are ignored: a sender can forge those.
func authenticated(header mail.Header, authservID, sender string) bool {
domain := sender[strings.LastIndex(sender, "@")+1:]
for _, value := range header.Values("Authentication-Results") {
id, results, err := authres.Parse(value)
if err != nil || !strings.EqualFold(id, authservID) {
continue
}
if parts := strings.SplitN(sec, "\r\n\r\n", 2); len(parts) == 2 {
return strings.TrimSpace(strings.TrimRight(parts[1], "\r\n-"))
}
if parts := strings.SplitN(sec, "\n\n", 2); len(parts) == 2 {
return strings.TrimSpace(strings.TrimRight(parts[1], "\n-"))
for _, result := range results {
switch r := result.(type) {
case *authres.DMARCResult:
if r.Value == authres.ResultPass {
return true
}
case *authres.DKIMResult:
if r.Value == authres.ResultPass && strings.EqualFold(r.Domain, domain) {
return true
}
}
}
}
return ""
return false
}
func extractBoundary(line string) string {
// boundary="xxx" or boundary=xxx
line = strings.TrimPrefix(line, "boundary=")
line = strings.TrimSpace(line)
line = strings.Trim(line, "\"")
// Stop at semicolon or whitespace.
if idx := strings.IndexAny(line, " ;\r\n"); idx >= 0 {
return line[:idx]
}
return line
}
// sendReply delivers a reply to the original sender via SMTP relay.
func (g *gateway) sendReply(to, from, text string) error {
msg := fmt.Sprintf("From: %s\r\nTo: %s\r\nSubject: Re: %s\r\n\r\n%s",
from, to, truncateSubject(text), text)
var auth smtp.Auth
if g.relayUser != "" {
host, _, _ := net.SplitHostPort(g.relayAddr)
auth = smtp.PlainAuth("", g.relayUser, g.relayPass, host)
}
// Try TLS first, fall back to plain.
c, err := smtp.Dial(g.relayAddr)
if err != nil {
return fmt.Errorf("dial relay: %w", err)
}
defer func() { _ = c.Close() }()
if ok, _ := c.Extension("STARTTLS"); ok {
tlsCfg := &tls.Config{ServerName: serverName(g.relayAddr)}
if err := c.StartTLS(tlsCfg); err != nil {
return fmt.Errorf("starttls: %w", err)
// plainText returns the first text/plain part.
func plainText(reader *mail.Reader) (string, error) {
for {
part, err := reader.NextPart()
if errors.Is(err, io.EOF) {
return "", errors.New("message has no text/plain part")
}
}
if auth != nil {
if err := c.Auth(auth); err != nil {
g.log.Warn("email relay auth failed", "err", err)
if err != nil {
return "", fmt.Errorf("read part: %w", err)
}
inline, ok := part.Header.(*mail.InlineHeader)
if !ok {
continue
}
if contentType, _, _ := inline.ContentType(); contentType != "text/plain" {
continue
}
body, err := io.ReadAll(part.Body)
if err != nil {
return "", fmt.Errorf("read body: %w", err)
}
return strings.TrimSpace(string(body)), nil
}
if err := c.Mail(from); err != nil {
return fmt.Errorf("mail from: %w", err)
}
if err := c.Rcpt(to); err != nil {
return fmt.Errorf("rcpt to: %w", err)
}
wc, err := c.Data()
if err != nil {
return fmt.Errorf("data: %w", err)
}
_, err = io.WriteString(wc, msg)
if err != nil {
return fmt.Errorf("write: %w", err)
}
return wc.Close()
}
func serverName(addr string) string {
host, _, err := net.SplitHostPort(addr)
if err != nil {
return "localhost"
func sendReply(s settings, to, subject, inReplyTo, text string) error {
if !strings.HasPrefix(strings.ToLower(subject), "re:") {
subject = "Re: " + subject
}
return host
}
var header mail.Header
header.SetAddressList("From", []*mail.Address{{Address: s.username}})
header.SetAddressList("To", []*mail.Address{{Address: to}})
header.SetSubject(subject)
header.SetDate(time.Now())
if err := header.GenerateMessageID(); err != nil {
return err
}
if inReplyTo != "" {
header.SetMsgIDList("In-Reply-To", []string{inReplyTo})
}
header.SetContentType("text/plain", map[string]string{"charset": "utf-8"})
func truncateSubject(text string) string {
if len(text) > 60 {
return text[:57] + "..."
var body strings.Builder
writer, err := mail.CreateSingleInlineWriter(&body, header)
if err != nil {
return err
}
return text
if _, err := io.WriteString(writer, text); err != nil {
return err
}
if err := writer.Close(); err != nil {
return err
}
auth := sasl.NewPlainClient("", s.username, s.password)
if err := smtp.SendMail(s.smtpAddr, auth, s.username, []string{to}, strings.NewReader(body.String())); err != nil {
return fmt.Errorf("send reply: %w", err)
}
return nil
}
+32
View File
@@ -0,0 +1,32 @@
package main
import (
"testing"
"github.com/emersion/go-message/mail"
)
func TestAuthenticated(t *testing.T) {
for _, tc := range []struct {
name string
results []string
want bool
}{
{"dmarc pass", []string{"mx.example.net; dmarc=pass header.from=a.com"}, true},
{"aligned dkim pass", []string{"mx.example.net; dkim=pass header.d=a.com"}, true},
{"dkim pass for another domain", []string{"mx.example.net; dkim=pass header.d=evil.com"}, false},
{"forged by another authserv", []string{"mx.evil.com; dmarc=pass header.from=a.com"}, false},
{"dmarc fail", []string{"mx.example.net; dmarc=fail header.from=a.com"}, false},
{"no results", nil, false},
} {
t.Run(tc.name, func(t *testing.T) {
var h mail.Header
for _, v := range tc.results {
h.Add("Authentication-Results", v)
}
if got := authenticated(h, "mx.example.net", "me@a.com"); got != tc.want {
t.Fatalf("authenticated = %v, want %v", got, tc.want)
}
})
}
}
+2 -2
View File
@@ -1,7 +1,7 @@
apiVersion: dev.archie.package.v1
displayName: Email channel
description: Email chat channel: receive mail over SMTP, reply through an SMTP relay.
version: 1.0.0
description: "Email chat channel: polls a mailbox over IMAP, routes mail from allowed, DMARC/DKIM-authenticated senders, replies over SMTP."
version: 2.0.0
contributes:
extensions:
- surface: channel
+5
View File
@@ -4,6 +4,11 @@ go 1.27
require (
code.gitea.io/sdk/gitea v0.25.1
github.com/emersion/go-imap/v2 v2.0.0-beta.8
github.com/emersion/go-message v0.18.2
github.com/emersion/go-msgauth v0.7.0
github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6
github.com/emersion/go-smtp v0.25.0
github.com/google/go-github/v78 v78.0.0
github.com/hashicorp/go-plugin v1.8.0
google.golang.org/grpc v1.84.0
+33
View File
@@ -9,6 +9,16 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davidmz/go-pageant v1.0.2 h1:bPblRCh5jGU+Uptpz6LgMZGD5hJoOt7otgT454WvHn0=
github.com/davidmz/go-pageant v1.0.2/go.mod h1:P2EDDnMqIwG5Rrp05dTRITj9z2zpGcD9efWSkTNKLIE=
github.com/emersion/go-imap/v2 v2.0.0-beta.8 h1:5IXZK1E33DyeP526320J3RS7eFlCYGFgtbrfapqDPug=
github.com/emersion/go-imap/v2 v2.0.0-beta.8/go.mod h1:dhoFe2Q0PwLrMD7oZw8ODuaD0vLYPe5uj2wcOMnvh48=
github.com/emersion/go-message v0.18.2 h1:rl55SQdjd9oJcIoQNhubD2Acs1E6IzlZISRTK7x/Lpg=
github.com/emersion/go-message v0.18.2/go.mod h1:XpJyL70LwRvq2a8rVbHXikPgKj8+aI0kGdHlg16ibYA=
github.com/emersion/go-msgauth v0.7.0 h1:vj2hMn6KhFtW41kshIBTXvp6KgYSqpA/ZN9Pv4g1INc=
github.com/emersion/go-msgauth v0.7.0/go.mod h1:mmS9I6HkSovrNgq0HNXTeu8l3sRAAuQ9RMvbM4KU7Ck=
github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6 h1:oP4q0fw+fOSWn3DfFi4EXdT+B+gTtzx8GC9xsc26Znk=
github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6/go.mod h1:iL2twTeMvZnrg54ZoPDNfJaJaqy0xIQFuBdrLsmspwQ=
github.com/emersion/go-smtp v0.25.0 h1:krfiHrme2JbJYDh0DGuSRbvPpbnQTH/v9CIfPincl1I=
github.com/emersion/go-smtp v0.25.0/go.mod h1:ZtRRkbTyp2XTHCA+BmyTFTrj8xY4I+b4McvHxCU2gsQ=
github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
github.com/go-fed/httpsig v1.1.0 h1:9M+hb0jkEICD8/cAiNqEB66R87tTINszBRTjwjQzWcI=
@@ -47,34 +57,57 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE=
golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0=
golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E=