From 21640ffd9e3cc838d6c788992beafc1c6b85d485 Mon Sep 17 00:00:00 2001 From: feco Date: Tue, 17 Nov 2026 18:43:39 +0000 Subject: [PATCH] Amazon SES as the mail sender - worker: without SMTP_URL, the SES SMTP address is built from the AWS access key and secret in .env.secrets (several common names, any case); the SMTP password is derived from the secret as AWS documents; region eu-central-1, port 2587 (DigitalOcean blocks 25/465/587) - deploy compose: no empty SMTP_URL in the worker's environment (it overrode .env.secrets); MAIL_FROM defaults to hello@sorsfonalak.hu - docs/levelkuldes.md rewritten for SES (domain, DKIM, custom MAIL FROM, sandbox, firewall); privacy policy names AWS as the mail processor Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL --- Cargo.lock | 3 + Cargo.toml | 1 + deploy/.env.example | 6 +- deploy/docker-compose.yml | 6 +- docs/levelkuldes.md | 99 ++++++---- .../frontend/src/app/adatvedelem/page.tsx | 4 +- services/worker/Cargo.toml | 3 + services/worker/README.md | 2 + services/worker/src/config.rs | 15 +- services/worker/src/main.rs | 6 +- services/worker/src/ses.rs | 172 ++++++++++++++++++ 11 files changed, 274 insertions(+), 43 deletions(-) create mode 100644 services/worker/src/ses.rs diff --git a/Cargo.lock b/Cargo.lock index de33d31..7b8ca1f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2875,14 +2875,17 @@ dependencies = [ "analysis-prompt", "anyhow", "axum", + "base64 0.22.1", "db", "email-templates", + "hmac", "lettre", "rand 0.9.5", "reqwest", "serde", "serde_json", "service-kit", + "sha2", "sqlx", "time", "tokio", diff --git a/Cargo.toml b/Cargo.toml index 1dfedd9..aa52438 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -35,6 +35,7 @@ argon2 = { version = "0.5", features = ["std"] } axum = "0.8" axum-extra = { version = "0.10", features = ["cookie"] } base64 = "0.22" +hmac = "0.12" jsonwebtoken = { version = "9", default-features = false } lettre = { version = "0.11", default-features = false, features = ["builder", "hostname", "smtp-transport", "tokio1", "tokio1-rustls", "webpki-roots", "ring"] } rand = "0.9" diff --git a/deploy/.env.example b/deploy/.env.example index e390168..93915f8 100644 --- a/deploy/.env.example +++ b/deploy/.env.example @@ -10,9 +10,9 @@ GOOGLE_CLIENT_IDS= # These accounts become admins at their first login BOOTSTRAP_ADMIN_EMAILS= -# Outgoing mail (see docs/levelkuldes.md). DigitalOcean blocks ports 25/465/587: use 2525. -# e.g. smtp://login%40smtp-brevo.com:KEY@smtp-relay.brevo.com:2525?tls=required -SMTP_URL= +# Outgoing mail: Amazon SES (docs/levelkuldes.md). The credentials go to .env.secrets: +# SES_SMTP_USERNAME + SES_SMTP_PASSWORD, or AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY. +SES_REGION=eu-central-1 MAIL_FROM=Sorsfonalak # invite: new accounts need an invitation (default); open: anyone can sign up diff --git a/deploy/docker-compose.yml b/deploy/docker-compose.yml index d59039f..094a427 100644 --- a/deploy/docker-compose.yml +++ b/deploy/docker-compose.yml @@ -104,8 +104,10 @@ services: image: ${REGISTRY_PREFIX:-registry.sagifer.com/sagifer/sorsfonalak}-worker:${TAG:-latest} environment: DATABASE_URL: postgres://sorsfonalak:${POSTGRES_PASSWORD}@postgres:5432/sorsfonalak - SMTP_URL: ${SMTP_URL:-} - MAIL_FROM: ${MAIL_FROM:-} + # SMTP_URL or the SES credentials come from .env.secrets (docs/levelkuldes.md); + # listing them here with an empty default would override that file. + SES_REGION: ${SES_REGION:-eu-central-1} + MAIL_FROM: ${MAIL_FROM:-Sorsfonalak } PUBLIC_BASE_URL: https://${DOMAIN} env_file: - path: .env.secrets diff --git a/docs/levelkuldes.md b/docs/levelkuldes.md index 0ab2087..d643cf0 100644 --- a/docs/levelkuldes.md +++ b/docs/levelkuldes.md @@ -1,60 +1,95 @@ -# Levélküldés élesben (meghívók, értesítések) +# Levélküldés élesben: Amazon SES Élesben most nincs levélküldő beállítva (`SMTP_URL` üres), így minden levél az `email_outbox` táblában vár. Amíg ez így van, a meghívót kézzel is továbbadhatod: az admin „Meghívók” oldala küldés után kiírja a linket („Link másolása”). -A meghívó a legkényesebb levéltípus, mert a címzett nem kérte. A spammappát elsősorban a feladó hírneve és a domain hitelesítése dönti el, a sablon csak ezután számít. Ezért kell a lenti négy lépés. +A meghívó a legkényesebb levéltípus, mert a címzett nem kérte. A spammappát elsősorban a feladó hírneve és a domain hitelesítése dönti el, a sablon csak ezután számít. Ezért kellenek a lenti lépések. -## 1. Levélküldő szolgáltatás +A SES ára 1000 levelenként 0,10 USD; a mi forgalmunknál ez havi néhány cent. -Javaslat: **Brevo** (EU-s, napi 300 levélig ingyenes; egy induló, meghívásos oldalnak bőven elég). Ha később fontosabb lesz a kézbesítési arány, a Postmark (fizetős) a legjobb; a beállítás ugyanígy megy. +## 1. Régió és domain (SES konzol) -A **DigitalOcean** a dropleteken alapból tiltja a kimenő SMTP-portokat (25, 465, 587), ezért a **2525-ös portot** kell használni; ezt a Brevo és a Postmark is tudja. +1. **Régió:** `eu-central-1` (Frankfurt), hogy az adatok az EU-ban maradjanak. Minden lépést ebben a régióban kell elvégezni, mert a SES-beállítások régiónként külön élnek. +2. *Configuration → Identities → Create identity → Domain*: `sorsfonalak.hu`. + - **Easy DKIM**, RSA 2048 bit. A SES három CNAME-rekordot ad (lásd 3. pont). + - **Custom MAIL FROM domain:** `mail.sorsfonalak.hu`, és *Behavior on MX failure*: *Use default MAIL FROM domain*. Ettől az SPF is a saját domainünkre szól, ami a DMARC-nál számít. Ehhez egy MX- és egy TXT-rekord kell. +3. A domain igazolása után bármelyik `@sorsfonalak.hu` cím lehet feladó. Javaslat: `hello@sorsfonalak.hu`. A `noreply` cím a szűrőknél rosszabb, és válaszolni sem lehet rá. -A droplet saját tűzfala (`sorsfonalak-fw`, DigitalOcean → Networking → Firewalls) a kimenő forgalmat is szűri: az **Outbound rules** közé fel kell venni a **TCP 2525**-öt (cél: All IPv4, All IPv6), különben a worker nem éri el a levélküldőt. +## 2. Kilépés a homokozóból (sandbox) -1. Brevo-fiók létrehozása. -2. *Senders, Domains & Dedicated IPs → Domains → Add a domain*: `sorsfonalak.hu`. A Brevo kiírja a szükséges DNS-rekordokat (lásd 2. pont). -3. *Senders*: feladó felvétele, javaslat: `hello@sorsfonalak.hu`. A `noreply` cím a szűrőknél rosszabb, és válaszolni sem lehet rá. -4. *SMTP & API → SMTP*: itt van az SMTP-login (`…@smtp-brevo.com` alakú) és egy új **SMTP-kulcs** (ez a jelszó). +Új SES-fiók homokozóban indul. Ilyenkor: +- csak igazolt címekre lehet küldeni (*Identities → Create identity → Email address*; teszteléshez a saját címed elég); +- naponta legfeljebb 200 levél megy ki. -## 2. DNS a Cloudflare-en +Meghívót idegen címre csak éles hozzáféréssel lehet küldeni: *Account dashboard → Request production access*. Az AWS kézzel bírálja el, általában egy napon belül. A kérésben érdemes leírni: +- tranzakciós levelek (megerősítés, értesítés) és meghívók egy zártkörű oldalra; +- meghívót csak az admin küld, személyesen ismert embereknek, kis mennyiségben; +- minden meghívóban egykattintásos leiratkozás van, a leiratkozott címekre többé nem megy levél; +- a visszapattanó és panaszos címeket a SES fiókszintű tiltólistája kezeli (*Suppression list*: bounces és complaints). -A rekordokat a Brevo pontosan megadja; ezek szoktak lenni: +Fontos: ha a visszapattanási arány 5%, vagy a panaszarány 0,1% fölé megy, az AWS felfüggesztheti a küldést. Ezért csak olyan címre küldj meghívót, amelyről tudod, hogy él. + +## 3. DNS a Cloudflare-en | Típus | Név | Tartalom | |---|---|---| -| TXT | `sorsfonalak.hu` | `brevo-code:…` (a domain igazolása) | -| CNAME | `brevo1._domainkey` | a Brevo által megadott cél (DKIM) | -| CNAME | `brevo2._domainkey` | a Brevo által megadott cél (DKIM) | +| CNAME ×3 | `._domainkey` | `.dkim.amazonses.com` (a SES konzol kiírja mindhármat) | +| MX | `mail` | `feedback-smtp.eu-central-1.amazonses.com`, prioritás 10 | +| TXT | `mail` | `v=spf1 include:amazonses.com ~all` | | TXT | `_dmarc` | `v=DMARC1; p=none; rua=mailto:` | -- A CNAME-ek legyenek **DNS only** (szürke felhő), különben a DKIM nem működik. -- SPF: ha a Brevo kér SPF-et, egy domainnek csak **egy** `v=spf1` rekordja lehet, a szolgáltatókat abba kell összevonni (például `v=spf1 include:spf.brevo.com ~all`). -- DMARC: induláskor `p=none` (csak jelentés). Ha pár hétig minden levél átmegy a DKIM-en, szigorítható `p=quarantine`-ra. -- Ha a `hello@sorsfonalak.hu` címre érkező válaszokat is olvasni szeretnéd: a Cloudflare *Email Routing* ingyen továbbítja őket a Gmailedre. Ez MX- és SPF-rekordot is ad; az SPF-et ilyenkor a Brevóéval egy rekordba kell összevonni. +- Minden rekord **DNS only** (szürke felhő) legyen; a proxyzott CNAME-mel a DKIM nem működik. +- DMARC: induláskor `p=none` (csak jelentés). Ha pár hétig minden levél átmegy, szigorítható `p=quarantine`-ra. +- Ha a `hello@sorsfonalak.hu` címre érkező válaszokat is olvasni szeretnéd: a Cloudflare *Email Routing* ingyen továbbítja őket a Gmailedre. Ez a fő domainre (`sorsfonalak.hu`) tesz MX- és SPF-rekordot, ami nem ütközik a `mail.` aldomain rekordjaival. -## 3. A szerver `.env` fájlja +## 4. Hozzáférés -`/opt/sorsfonalak/.env`: +Két út van, mindkettő a szerver `.env.secrets` fájljába kerül (kis- vagy nagybetűvel is jó): -``` -SMTP_URL=smtp://:@smtp-relay.brevo.com:2525?tls=required -MAIL_FROM=Sorsfonalak -``` +- **SMTP-hozzáférés** (*SMTP settings → Create SMTP credentials*): egy IAM-felhasználó, amely csak levelet küldhet. + ``` + SES_SMTP_USERNAME=AKIA... + SES_SMTP_PASSWORD=... + ``` +- **IAM-kulcspár**, amelynek van `ses:SendRawEmail` joga: + ``` + AWS_ACCESS_KEY_ID=AKIA... + AWS_SECRET_ACCESS_KEY=... + ``` + Más nevek is jók: a kulcsnál `SES_AUTH_KEY`, `SES_ACCESS_KEY`, `SES_KEY`, `AUTH_KEY`, a titoknál `SES_SECRET`, `SES_SECRET_KEY`, `AWS_SECRET`, `AUTH_SECRET` (a teljes lista: `services/worker/src/ses.rs`). + A worker ebből az AWS által leírt módon kiszámolja az SMTP-jelszót. Ha az `AWS_SECRET_ACCESS_KEY` helyére az SMTP-jelszót írtad, azt is felismeri, és változatlanul használja. -- A loginban lévő `@` jelet `%40`-re kell írni (például `abc123%40smtp-brevo.com`), mert az URL-ben az `@` választja el a jelszót a géptől. -- Utána: `docker compose up -d worker`. A naplóban ennek kell megjelennie: `e-mail delivery enabled`. +A régió alapból `eu-central-1` (Frankfurt); felülírható a `SES_REGION` változóval. A port 2587, ezt a `SES_SMTP_PORT` írja felül. URL-kódolásra itt nincs szükség, mert a worker maga állítja össze a címet. + +## 5. Tűzfal + +A DigitalOcean a dropleteken tiltja a szokásos kimenő SMTP-portokat (25, 465, 587). A SES erre a **2587**-es portot (STARTTLS) is kínálja. + +A droplet saját tűzfala (`sorsfonalak-fw`, DigitalOcean → Networking → Firewalls) a kimenő forgalmat is szűri. Az **Outbound rules** közé fel kell venni a **TCP 2587**-et (cél: All IPv4, All IPv6), különben a worker nem éri el a SES-t. + +## 6. Indítás + +- A `.env` fájlban opcionális: `MAIL_FROM=Sorsfonalak ` (ez az alapérték is). +- Utána: `docker compose up -d worker`. A naplóban ennek kell megjelennie: `e-mail delivery enabled`, `via=Amazon SES eu-central-1:2587, credentials from …`. - Az eddig várakozó levelek ekkor kimennek. Ha ezt nem szeretnéd, előtte töröld őket: `DELETE FROM email_outbox WHERE sent_at IS NULL;`. +- Hibaüzenetek a naplóban: + - `535 Authentication Credentials Invalid`: hibás kulcs, vagy az IAM-felhasználónak nincs `ses:SendRawEmail` joga; + - `554 Message rejected: Email address is not verified`: a fiók még homokozóban van, és a címzett nincs igazolva; + - időtúllépés: a tűzfalon nincs engedélyezve a kimenő 2587-es port. +- Ha mégis kész SMTP-címet adnál meg, az `SMTP_URL` mindig elsőbbséget élvez a SES-változókkal szemben. -## 4. Próba +## 7. Próba 1. Admin → Meghívók → **Teszt küldése magamnak**: megérkezik-e, és nem a spamben van-e. 2. A Gmailben a levélnél *⋮ → Eredeti megjelenítése*: az SPF, a DKIM és a DMARC mellett is `PASS` álljon. -3. A [mail-tester.com](https://www.mail-tester.com) ad egy egyszeri címet: küldj rá meghívót az admin oldalról (utána vond vissza), és nézd meg a pontszámot. 9/10 fölött jó. +3. A [mail-tester.com](https://www.mail-tester.com) ad egy egyszeri címet. Küldj rá meghívót az admin oldalról (utána vond vissza), és nézd meg a pontszámot; 9/10 fölött jó. Ehhez már éles hozzáférés kell. ## Amit a kód már elintéz -- HTML és szöveges változat ugyanazzal a tartalommal; egyhasábos, képek és követés nélkül; minden link a saját domainre mutat. -- `Message-ID` a feladó domainjén. +- HTML és szöveges változat ugyanazzal a tartalommal. Egyhasábos, képek és követés nélkül, minden link a saját domainre mutat. - `List-Unsubscribe` és `List-Unsubscribe-Post` (RFC 8058): a Gmail és a többi levelező saját „Leiratkozás” gombot mutat. Aki leiratkozik, annak a címére soha többé nem megy meghívó (`email_optouts`, csak a cím hash-e). -- Meghívót csak admin küldhet; egy meghívó legfeljebb háromszor megy ki, 24 óránként egyszer. A személyes üzenet legfeljebb 300 karakter, és nem lehet benne link. +- A worker saját domaines `Message-ID`-t tesz a levélre. A SES ezt a sajátjára cseréli, ami rendben van. +- Meghívót csak admin küldhet. Egy meghívó legfeljebb háromszor megy ki, 24 óránként egyszer. A személyes üzenet legfeljebb 300 karakter, és nem lehet benne link. + +## Később + +A visszapattanásokról és panaszokról a SES utólag, SNS-értesítésben szól; az SMTP-kapcsolat ezt nem jelzi. Ha lesz forgalom, érdemes bekötni egy SNS → backend webhookot. Ez a meghívólistán megjelölné a visszapattant címeket, és a panaszt tevőket a leiratkozottak közé tenné. diff --git a/services/frontend/src/app/adatvedelem/page.tsx b/services/frontend/src/app/adatvedelem/page.tsx index 5eb1eb5..fa99bae 100644 --- a/services/frontend/src/app/adatvedelem/page.tsx +++ b/services/frontend/src/app/adatvedelem/page.tsx @@ -139,8 +139,8 @@ export default async function PrivacyPage() { Google LLC – bejelentkezés Google-fiókkal.
  • - Levélküldő szolgáltató – a rendszerlevelek és a meghívók kézbesítése; a neve az indításkor - itt lesz feltüntetve. + Amazon Web Services EMEA SARL (Amazon SES) – a rendszerlevelek és a meghívók kézbesítése; + az Európai Unióban (Frankfurt).
  • OpenRouter, Inc. és az általa elért modellszolgáltató (jelenleg{" "} diff --git a/services/worker/Cargo.toml b/services/worker/Cargo.toml index f7198af..3ad8120 100644 --- a/services/worker/Cargo.toml +++ b/services/worker/Cargo.toml @@ -13,11 +13,14 @@ email-templates.workspace = true service-kit.workspace = true anyhow.workspace = true axum.workspace = true +base64.workspace = true +hmac.workspace = true lettre.workspace = true rand.workspace = true reqwest.workspace = true serde.workspace = true serde_json.workspace = true +sha2.workspace = true sqlx.workspace = true time.workspace = true tokio.workspace = true diff --git a/services/worker/README.md b/services/worker/README.md index 8501944..30b3059 100644 --- a/services/worker/README.md +++ b/services/worker/README.md @@ -63,6 +63,8 @@ Ugyanazt a radix-elemzést több modellel is megírja, véletlenszerű betűkkel |---|---|---| | `DATABASE_URL` | – (kötelező) | PostgreSQL kapcsolat | | `SMTP_URL` | – | `smtp://mailpit:1025` (fejlesztés), `smtp://user:pass@host:587?tls=required` (STARTTLS), `smtps://user:pass@host:465` (TLS) | +| `AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY` | – | Amazon SES, ha nincs `SMTP_URL` (a `.env.secrets` fájlból; más nevek is jók, lásd `src/ses.rs`). A titkos kulcsból a worker kiszámolja az SMTP-jelszót. Helyettük `SES_SMTP_USERNAME` + `SES_SMTP_PASSWORD` is megadható | +| `SES_REGION`, `SES_SMTP_PORT` | `eu-central-1`, `2587` | SES-régió és port (a DigitalOcean a 25-ös, 465-ös és 587-es portot tiltja) | | `MAIL_FROM` | `Sorsfonalak ` | feladó | | `POLL_INTERVAL_SECS` | `30` | tartalék lekérdezési időköz | | `MAX_EMAIL_ATTEMPTS` | `8` | ennyi próbálkozás után sikertelen a levél | diff --git a/services/worker/src/config.rs b/services/worker/src/config.rs index a0918aa..3949841 100644 --- a/services/worker/src/config.rs +++ b/services/worker/src/config.rs @@ -8,8 +8,11 @@ use lettre::message::Mailbox; pub struct Config { pub database_url: String, /// `smtp://host:port` (plain, e.g. Mailpit), `smtp://user:pass@host:587?tls=required` - /// (STARTTLS) or `smtps://...` (TLS). Unset: e-mails stay in the outbox. + /// (STARTTLS) or `smtps://...` (TLS). Without it, Amazon SES from the AWS + /// variables (see `ses.rs`). Neither: e-mails stay in the outbox. pub smtp_url: Option, + /// For the log: where the SMTP address came from (no secrets). + pub smtp_about: Option, /// Sender, e.g. `Sorsfonalak `. pub mail_from: Mailbox, /// Fallback polling interval; new e-mails are picked up at once via LISTEN/NOTIFY. @@ -44,9 +47,17 @@ where impl Config { pub fn from_env() -> anyhow::Result { let mail_from = var("MAIL_FROM").unwrap_or_else(|| "Sorsfonalak ".into()); + let (smtp_url, smtp_about) = match var("SMTP_URL") { + Some(url) => (Some(url), None), + None => match crate::ses::smtp_url(|name| std::env::var(name).ok())? { + Some((url, about)) => (Some(url), Some(about)), + None => (None, None), + }, + }; Ok(Self { database_url: var("DATABASE_URL").context("DATABASE_URL is required")?, - smtp_url: var("SMTP_URL"), + smtp_url, + smtp_about, mail_from: mail_from.parse().with_context(|| format!("invalid MAIL_FROM '{mail_from}'"))?, poll_interval: Duration::from_secs(parsed("POLL_INTERVAL_SECS", 30)?), max_email_attempts: parsed("MAX_EMAIL_ATTEMPTS", 8)?, diff --git a/services/worker/src/main.rs b/services/worker/src/main.rs index 9b052c3..2f07250 100644 --- a/services/worker/src/main.rs +++ b/services/worker/src/main.rs @@ -15,6 +15,7 @@ mod cleanup; mod compare; mod config; mod email; +mod ses; mod templates { pub use email_templates::*; } @@ -93,10 +94,11 @@ async fn main() -> anyhow::Result<()> { match &config.smtp_url { Some(url) => { let delivery = email::Delivery::new(pool.clone(), email::Mailer::smtp(url)?, &config); - tracing::info!(host = %email::smtp_host(url), "e-mail delivery enabled"); + let via = config.smtp_about.clone().unwrap_or_else(|| "SMTP_URL".into()); + tracing::info!(host = %email::smtp_host(url), via = %via, from = %config.mail_from, "e-mail delivery enabled"); jobs.spawn(email::run(delivery, config.poll_interval, stop.clone())); } - None => tracing::warn!("SMTP_URL is not set: e-mails stay in the outbox"), + None => tracing::warn!("neither SMTP_URL nor SES credentials are set: e-mails stay in the outbox"), } match &config.openrouter_api_key { Some(key) => { diff --git a/services/worker/src/ses.rs b/services/worker/src/ses.rs new file mode 100644 index 0000000..b275072 --- /dev/null +++ b/services/worker/src/ses.rs @@ -0,0 +1,172 @@ +//! Amazon SES over SMTP, configured from AWS-style variables when `SMTP_URL` +//! is not set (so the credentials can sit in `.env.secrets` as they are). +//! +//! Accepted (upper or lower case): +//! * `SES_SMTP_USERNAME` + `SES_SMTP_PASSWORD`: SMTP credentials from the SES console; +//! * or `AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY` (or another name from +//! `KEY_NAMES` / `SECRET_NAMES`, e.g. `ses_auth_key` + `ses_secret`): an IAM +//! key allowed `ses:SendRawEmail`; the SMTP +//! password is derived from it as AWS documents. If the "secret" already is +//! an SMTP password, it is used as it is. +//! * `SES_REGION` / `AWS_REGION` / `AWS_DEFAULT_REGION` (default `eu-central-1`), +//! `SES_SMTP_PORT` (default 2587, STARTTLS: DigitalOcean blocks 25, 465 and 587). + +use base64::Engine; +use base64::engine::general_purpose::STANDARD; +use hmac::{Hmac, Mac}; +use sha2::Sha256; + +pub const DEFAULT_REGION: &str = "eu-central-1"; + +/// Names the access key id may have in a secrets file. +const KEY_NAMES: &[&str] = &[ + "SES_ACCESS_KEY_ID", + "AWS_ACCESS_KEY_ID", + "SES_AUTH_KEY", + "SES_ACCESS_KEY", + "SES_KEY", + "AWS_AUTH_KEY", + "AWS_ACCESS_KEY", + "AUTH_KEY", +]; +/// Names the secret access key may have. +const SECRET_NAMES: &[&str] = &[ + "SES_SECRET_ACCESS_KEY", + "AWS_SECRET_ACCESS_KEY", + "SES_SECRET", + "SES_SECRET_KEY", + "SES_AUTH_SECRET", + "AWS_SECRET", + "AWS_SECRET_KEY", + "AUTH_SECRET", +]; +const DEFAULT_PORT: u16 = 2587; + +/// The first set variable among `names`, each tried in upper and lower case. +fn var(lookup: &impl Fn(&str) -> Option, names: &[&str]) -> Option<(String, String)> { + names.iter().find_map(|name| { + [name.to_string(), name.to_lowercase()] + .into_iter() + .find_map(|n| lookup(&n).map(|v| v.trim().to_owned()).filter(|v| !v.is_empty()).map(|v| (n, v))) + }) +} + +/// The SES SMTP address and a description for the log (no secrets), if credentials are set. +pub fn smtp_url(lookup: impl Fn(&str) -> Option) -> anyhow::Result> { + let region = + var(&lookup, &["SES_REGION", "AWS_REGION", "AWS_DEFAULT_REGION"]).map_or(DEFAULT_REGION.into(), |(_, v)| v); + if !region.chars().all(|c| c.is_ascii_alphanumeric() || c == '-') { + anyhow::bail!("invalid SES region '{region}'"); + } + let port: u16 = match var(&lookup, &["SES_SMTP_PORT"]) { + Some((_, p)) => p.parse().map_err(|e| anyhow::anyhow!("invalid SES_SMTP_PORT '{p}': {e}"))?, + None => DEFAULT_PORT, + }; + let smtp = var(&lookup, &["SES_SMTP_USERNAME", "SES_SMTP_USER"]).zip(var(&lookup, &["SES_SMTP_PASSWORD"])); + let (user, password, source) = if let Some(((name, user), (_, password))) = smtp { + (user, password, name) + } else { + let key = var(&lookup, KEY_NAMES); + let secret = var(&lookup, SECRET_NAMES); + match (key, secret) { + (Some((name, key)), Some((_, secret))) => { + let password = if is_smtp_password(&secret) { secret } else { smtp_password(&secret, ®ion) }; + (key, password, name) + } + (None, None) => return Ok(None), + _ => anyhow::bail!("SES: both the access key id and the secret access key are needed"), + } + }; + let url = + format!("smtp://{}:{}@email-smtp.{region}.amazonaws.com:{port}?tls=required", encode(&user), encode(&password)); + Ok(Some((url, format!("Amazon SES {region}:{port}, credentials from {source}")))) +} + +/// The SES SMTP password of an IAM secret access key (AWS docs, "Obtaining +/// Amazon SES SMTP credentials": signature version 4, `SendRawEmail`). +pub fn smtp_password(secret: &str, region: &str) -> String { + fn sign(key: &[u8], msg: &str) -> Vec { + let mut mac = Hmac::::new_from_slice(key).expect("HMAC takes any key length"); + mac.update(msg.as_bytes()); + mac.finalize().into_bytes().to_vec() + } + let mut signature = sign(format!("AWS4{secret}").as_bytes(), "11111111"); + for part in [region, "ses", "aws4_request", "SendRawEmail"] { + signature = sign(&signature, part); + } + let mut bytes = vec![0x04]; + bytes.extend(signature); + STANDARD.encode(bytes) +} + +/// An SMTP password is a version byte (4) and a 32-byte signature, in base64; +/// an IAM secret key is 40 characters. +fn is_smtp_password(s: &str) -> bool { + s.len() == 44 && STANDARD.decode(s).is_ok_and(|b| b.len() == 33 && b[0] == 0x04) +} + +/// Percent-encoding for the user and password part of a URL. +fn encode(s: &str) -> String { + s.bytes() + .map(|b| match b { + b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' => (b as char).to_string(), + _ => format!("%{b:02X}"), + }) + .collect() +} + +#[cfg(test)] +mod tests { + use std::collections::HashMap; + + use super::*; + + fn env(pairs: &[(&str, &str)]) -> impl Fn(&str) -> Option { + let map: HashMap = pairs.iter().map(|(k, v)| (k.to_string(), v.to_string())).collect(); + move |k| map.get(k).cloned() + } + + #[test] + fn derives_the_smtp_password() { + // The value of AWS's Python example (docs: "Obtaining Amazon SES SMTP credentials") for this made-up key. + let password = smtp_password("wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY", "eu-central-1"); + assert_eq!(password, "BF0/eIJm0ruTHsSjOkRuOGzGF+zeSyE3aiRzrzUQ8LwG"); + assert!(is_smtp_password(&password)); + assert!(!is_smtp_password("wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY")); + } + + #[test] + fn url_from_variables() { + assert!(smtp_url(env(&[])).unwrap().is_none()); + let (url, about) = smtp_url(env(&[ + ("aws_access_key_id", "AKIAEXAMPLE"), + ("aws_secret_access_key", "BF0/eIJm0ruTHsSjOkRuOGzGF+zeSyE3aiRzrzUQ8LwG"), + ])) + .unwrap() + .unwrap(); + // already an SMTP password: kept, with + and / encoded + assert_eq!( + url, + "smtp://AKIAEXAMPLE:BF0%2FeIJm0ruTHsSjOkRuOGzGF%2BzeSyE3aiRzrzUQ8LwG@email-smtp.eu-central-1.amazonaws.com:2587?tls=required" + ); + assert_eq!(about, "Amazon SES eu-central-1:2587, credentials from aws_access_key_id"); + let (url, _) = smtp_url(env(&[ + ("SES_SMTP_USERNAME", "AKIA2"), + ("SES_SMTP_PASSWORD", "a/b+c="), + ("SES_REGION", "eu-west-1"), + ])) + .unwrap() + .unwrap(); + assert_eq!(url, "smtp://AKIA2:a%2Fb%2Bc%3D@email-smtp.eu-west-1.amazonaws.com:2587?tls=required"); + assert!(smtp_url(env(&[("AWS_ACCESS_KEY_ID", "AKIA")])).is_err()); + // other common names; a real secret key is turned into the SMTP password + let (url, about) = + smtp_url(env(&[("ses_auth_key", "AKIA3"), ("ses_secret", "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY")])) + .unwrap() + .unwrap(); + assert!( + url.starts_with("smtp://AKIA3:BF0%2FeIJm0ruTHsSjOkRuOGzGF%2BzeSyE3aiRzrzUQ8LwG@email-smtp.eu-central-1.") + ); + assert!(about.ends_with("from ses_auth_key")); + } +}