butterrobot
7565618efd
Some checks failed
Three defects in the SMTP backend, all predating the FMG-2 dependency upgrade.
## Authentication bypass
The credential check joined its two comparisons with `&&`, so it only rejected a client that got *both* halves wrong — a correct username with any password authenticated, as did a correct password with any username. Both comparisons now have to pass, and both are evaluated before either is acted on so the timing does not distinguish a wrong username from a wrong password. They compare SHA-256 digests through `subtle.ConstantTimeCompare`, which keeps the length of the configured credential out of the timing as well.
Fixing the comparison alone does not close the hole. go-smtp advertises `AUTH` but leaves enforcement to the backend, so a client could skip `AUTH` entirely and still have its message forwarded. The session now tracks authentication and refuses `MAIL`, `RCPT` and `DATA` without it.
Nor does the gate mean anything while the credentials it checks can be guessed. `SetDefaults` invented `Username = "username"` and `Password = "password"` when the config omitted them, with only a `slog.Warn` — so a `config.toml` naming nothing but a port and its recipients relayed to anyone who tried the obvious pair, for exactly the deployments that had configured the least. `Validate` now rejects unset credentials the way it already rejects an unusable target, and the invented defaults are gone.
**Behavior change:** a client that used to send without issuing `AUTH` now has to be configured with the credentials from `config.toml`, and a deployment that never set them will not start until it does. Both documented in the README.
## Remote denial of service
A malformed `Content-Type` reached `log.Fatalf`, which calls `os.Exit(1)`. One message with an attacker-controlled header terminated the daemon and took every other in-flight message with it. `Body()` now returns the parse error like the rest of the function does.
## Silent notification loss
`Data` logged forwarding errors and returned `250`, so a client whose notification reached no target at all treated the message as delivered and never retried. The reply now reflects what happened:
- `250` — at least one target accepted it. A *partial* failure is logged but still accepted, since a retry redelivers to every target and would duplicate the notification on the ones that already have it. This keeps the existing `TestPartialTargetFailure` contract.
- `451` — no target accepted it. Worth retrying.
- `550 5.6.0` — the message cannot be parsed. No retry can fix the same bytes.
- `550 5.3.5` — the recipient has no notification targets configured. A configuration fault; no retry can add targets. `LoadConfig` blocks such a config, so this is only reachable from one built in code.
## Session transaction state
`Session.Reset` was empty while go-smtp calls it after every message, so recipients accumulated across a connection and the second message on it was also forwarded to the first one's targets.
Fixing that introduced a data race, caught in review: `Reset` runs on the connection goroutine, but go-smtp runs `Data` on its own goroutine for a `BDAT` transfer and does not block `RSET` during one. A mutex now guards the recipients and the authentication flag across `Rcpt`, `Data` and `Reset`, and `Data` snapshots the recipients up front instead of reading the slice while forwarding.
## Validation
`make format`, `make ci-lint` (0 issues), `make test` (`-race`, 94.2% coverage), `make check` and `make build` all pass locally.
Every regression test was confirmed to fail against the code it guards:
- the six original ones against `origin/main` — the malformed `Content-Type` one by killing the test binary outright, which is the reported DoS;
- `TestResetDuringChunkedTransferIsSynchronized` against `da8e8e4`, where `-race` reports `Session.Reset` racing `Session.Data` on all three runs attempted;
- `TestLoadConfigRejectsUnsetCredentials` against `da8e8e4`'s `config.go`.
## Known gaps, not addressed here
- `Body()` returns `("", nil)` for a `multipart/*` with an unusable boundary and for any media type that is neither `multipart/` nor `text/`, so an empty notification is pushed to every target and answered `250`.
- `forwardEmail` breaks after the first matching `[[Recipients]]` entry, so a message addressed to two matching entries notifies only the first and still answers `250`. Pre-existing.
- A message for an address matching no entry, with no `[CatchAll]`, is accepted with `250` and dropped. Rejecting at `RCPT` would be more honest.
- `smtp.ErrAuthRequired` is go-smtp's `502 5.7.0` where RFC 4954 §6 specifies `530 5.7.0`. Left on the library's own constant.
Closes FMG-3
Co-authored-by: Full-Stack Developer <me@fmartingr.com>
Reviewed-on: #9
Reviewed-by: Felipe M <me@fmartingr.com>
97 lines
2.6 KiB
Go
97 lines
2.6 KiB
Go
package smtp2shoutrrr
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"mime"
|
|
"mime/multipart"
|
|
"net/mail"
|
|
"strings"
|
|
)
|
|
|
|
// errMalformedMessage marks a message this server can never turn into a
|
|
// notification. Redelivering the same bytes produces the same failure, so the
|
|
// sender is told to give up rather than retry forever.
|
|
var errMalformedMessage = errors.New("malformed message")
|
|
|
|
type ReceivedEmail struct {
|
|
Recipients []string
|
|
Msg *mail.Message
|
|
body string
|
|
}
|
|
|
|
func (re *ReceivedEmail) Body() (string, error) {
|
|
if re.body == "" {
|
|
contentType := re.Msg.Header.Get("Content-Type")
|
|
|
|
if contentType == "" {
|
|
body, err := io.ReadAll(re.Msg.Body)
|
|
if err != nil {
|
|
return "", fmt.Errorf("failed to read email body: %w", err)
|
|
}
|
|
re.body = string(body)
|
|
} else {
|
|
mediaType, params, err := mime.ParseMediaType(contentType)
|
|
if err != nil {
|
|
return "", fmt.Errorf("%w: parsing Content-Type %q: %w", errMalformedMessage, contentType, err)
|
|
}
|
|
|
|
if strings.HasPrefix(mediaType, "multipart/") {
|
|
// Handle any multipart type (alternative, mixed, related, etc.)
|
|
mr := multipart.NewReader(re.Msg.Body, params["boundary"])
|
|
var htmlBody string
|
|
|
|
for {
|
|
part, err := mr.NextPart()
|
|
if err != nil {
|
|
break
|
|
}
|
|
|
|
partContentType := part.Header.Get("Content-Type")
|
|
slog.Debug("Processing email part", slog.String("content_type", partContentType))
|
|
|
|
// Prefer text/plain, but keep HTML as fallback
|
|
if strings.HasPrefix(partContentType, "text/plain") {
|
|
body := new(bytes.Buffer)
|
|
_, err = body.ReadFrom(part)
|
|
_ = part.Close()
|
|
if err != nil {
|
|
slog.Error("Failed to read part body", slog.String("err", err.Error()))
|
|
return "", fmt.Errorf("failed to read part body: %w", err)
|
|
}
|
|
|
|
re.body = body.String()
|
|
break // Found text/plain, use it
|
|
} else if strings.HasPrefix(partContentType, "text/html") && htmlBody == "" {
|
|
// Store HTML as fallback if no text/plain found
|
|
body := new(bytes.Buffer)
|
|
_, err = body.ReadFrom(part)
|
|
_ = part.Close()
|
|
if err == nil {
|
|
htmlBody = body.String()
|
|
}
|
|
} else {
|
|
_ = part.Close()
|
|
}
|
|
}
|
|
|
|
// If no text/plain was found, use HTML
|
|
if re.body == "" && htmlBody != "" {
|
|
re.body = htmlBody
|
|
}
|
|
} else if strings.HasPrefix(mediaType, "text/") {
|
|
// Handle non-multipart text content (text/plain, text/html, etc.)
|
|
body, err := io.ReadAll(re.Msg.Body)
|
|
if err != nil {
|
|
return "", fmt.Errorf("failed to read email body: %w", err)
|
|
}
|
|
re.body = string(body)
|
|
}
|
|
}
|
|
}
|
|
|
|
return re.body, nil
|
|
}
|