happyDomain/happyDeliver
2
0
Fork 0
Code Issues 10 Pull requests 2 Projects Releases Packages Wiki Activity Actions

Compare commits

base: happyDomain:14d5680970e44d000dc91b87e93f25bbb9178f4a
Branches Tags
happyDomain:master
happyDomain:renovate/lock-file-maintenance
happyDomain:build
happyDomain:renovate/major-vitest-monorepo
happyDomain:renovate/npm-svelte-vulnerability
happyDomain:renovate/npm-sveltejs-kit-vulnerability
happyDomain:f/rspamd
happyDomain:f/unsubscribe-link-detection
happyDomain:internal_resolver
happyDomain:renovate/eslint-plugin-svelte-3.x-lockfile
happyDomain:renovate/node-22.x-lockfile
happyDomain:renovate/eslint-compat-1.x-lockfile
happyDomain:renovate/sveltejs-kit-2.x-lockfile
happyDomain:renovate/svelte-5.x-lockfile
happyDomain:v1.2.0
happyDomain:v1.1.1
happyDomain:v1.1.0
happyDomain:v1.0.0
...
compare: happyDomain:4f45f86d9a21e28c10635059efbbe70bccf4fdf0
Branches Tags
happyDomain:renovate/lock-file-maintenance
happyDomain:master
happyDomain:build
happyDomain:renovate/major-vitest-monorepo
happyDomain:renovate/npm-svelte-vulnerability
happyDomain:renovate/npm-sveltejs-kit-vulnerability
happyDomain:f/rspamd
happyDomain:f/unsubscribe-link-detection
happyDomain:internal_resolver
happyDomain:renovate/eslint-plugin-svelte-3.x-lockfile
happyDomain:renovate/node-22.x-lockfile
happyDomain:renovate/eslint-compat-1.x-lockfile
happyDomain:renovate/sveltejs-kit-2.x-lockfile
happyDomain:renovate/svelte-5.x-lockfile
happyDomain:v1.2.0
happyDomain:v1.1.1
happyDomain:v1.1.0
happyDomain:v1.0.0

24 commits
14d5680970 ... 4f45f86d9a

Author SHA1 Message Date
Renovate Bot
4f45f86d9a chore(deps): update dependency typescript to v6
Some checks failed
renovate/artifacts Artifact file update failure
 2026-05-04 04:07:49 +00:00
Pierre-Olivier Mercier
09d777634c Readd missing go deps
Some checks failed
continuous-integration/drone/push Build is failing
Details
2026-05-04 11:15:53 +08:00
Renovate Bot
15120d8598 chore(deps): update module golang.org/x/net to v0.53.0
Some checks are pending
continuous-integration/drone/push Build is running
Details
2026-05-04 03:14:35 +00:00
Renovate Bot
6f6211e833 chore(deps): update module github.com/oapi-codegen/oapi-codegen/v2 to v2.7.0
Some checks are pending
continuous-integration/drone/push Build is running
Details
2026-05-04 03:14:23 +00:00
Renovate Bot
42cf6f450d chore(deps): update module github.com/jgltechnologies/gin-rate-limit to v1.5.8
Some checks are pending
continuous-integration/drone/push Build is running
Details
2026-05-04 03:13:54 +00:00
Pierre-Olivier Mercier
31a27c120b Add instruction to use with new happyDomain checker
Some checks are pending
continuous-integration/drone/push Build is pending
Details
2026-04-28 19:01:22 +07:00
Pierre-Olivier Mercier
396c51974a Extract OpenAPI schemas to separate file and move models to internal/model package
All checks were successful
continuous-integration/drone/push Build is passing
Details 
Split api/openapi.yaml schemas into api/schemas.yaml so structs can be
generated independently from the API server code. Models now generate
into internal/model/ via oapi-codegen, with the server referencing them
through import-mapping. Moved PtrTo helper to internal/utils and removed
storage.ReportSummary in favor of model.TestSummary.
 2026-04-09 18:36:27 +07:00
Pierre-Olivier Mercier
3eec5ce966 Remove unused xAlignedFrom prop from HeaderAnalysisCard
Some checks are pending
continuous-integration/drone/push Build is pending
Details
2026-04-09 18:05:11 +07:00
Pierre-Olivier Mercier
7422f6ed0a Add paginated test history listing with disable option 
Add GET /tests endpoint returning lightweight test summaries (grade,
score, domain, date) with pagination, using database-level JSON
extraction to avoid loading full report blobs. The feature can be
disabled with --disable-test-list flag. Frontend includes a new
/tests/ page with table view and a conditional "History" navbar link.

Fixes: https://github.com/happyDomain/happydeliver/issues/12
 2026-04-09 18:05:06 +07:00
Pierre-Olivier Mercier
e540377bd9 Don't penalize non iprev result nor aligned-from if non-existant
All checks were successful
continuous-integration/drone/push Build is passing
Details 
Bug: https://github.com/happyDomain/happydeliver/issues/11
 2026-03-27 17:57:48 +07:00
Pierre-Olivier Mercier
16b7dcb057 Incorporate DNSWL (whitelist) grade into blacklist scoring
All checks were successful
continuous-integration/drone/push Build is passing
Details 
CalculateScore now accepts a forWhitelist flag to handle whitelist
scoring logic separately. The final blacklist grade combines both
RBL and DNSWL results using MinGrade for a more accurate reputation
assessment.
 2026-03-26 10:36:27 +07:00
Pierre-Olivier Mercier
dfa38e8a26 Fix RBL score: return A+ when not listed on any blocklist 
Move the ListedCount check before scoringListCount calculation so we
return early with a perfect score when the IP/domain is not listed,
regardless of how many informational-only lists exist.
 2026-03-26 10:36:25 +07:00
Pierre-Olivier Mercier
dee848d887 Rebalance authentication score: SPF/DKIM/DMARC as core, penalties for optional results
Some checks are pending
continuous-integration/drone/push Build is running
Details 
IPRev and X-Aligned-From now only penalize on failure instead of
contributing positively. Core authentication (SPF/DKIM/DMARC) rebalanced
to 30 points each, BIMI stays at 10, totaling 100 base points.

Bug: https://github.com/happyDomain/happydeliver/issues/11
 2026-03-26 10:13:37 +07:00
Pierre-Olivier Mercier
b158336451 Filter Received-SPF header by receiver hostname 
Ensures parseLegacySPF only trusts Received-SPF headers where the
receiver= field matches the configured receiverHostname, preventing
incorrect SPF results from unrelated receivers.
 2026-03-26 10:13:37 +07:00
Pierre-Olivier Mercier
a36824cf27 Fix DKIM headers retrieval 
Bug: https://github.com/happyDomain/happydeliver/issues/11
 2026-03-26 10:13:28 +07:00
Pierre-Olivier Mercier
7d3009d7d0 Add rspamd symbol descriptions from embedded/API lookup 
Embed rspamd-symbols.json in the binary to provide human-readable
descriptions for rspamd symbols in reports. Optionally fetch fresh
symbols from a configurable rspamd API URL (--rspamd-api-url flag),
falling back to the embedded list on error. Update the frontend to
display descriptions alongside symbol names and scores.
 2026-03-26 09:51:45 +07:00
Pierre-Olivier Mercier
5c104f3c99 Merge RspamdSymbol into SpamTestDetail in OpenAPI spec 
Add params field to SpamTestDetail, update RspamdResult.symbols to
reference SpamTestDetail instead of the now-removed RspamdSymbol schema,
and update Go code accordingly.
 2026-03-26 08:58:13 +07:00
Pierre-Olivier Mercier
3c192f17fd Improve DKIM summary to distinguish missing records from invalid signatures
All checks were successful
continuous-integration/drone/push Build is passing
Details 
Use DNS records instead of authentication results to determine DKIM
presence, enabling a three-state display: passed (green), published but
invalid signature (yellow+red), or no DKIM at all (red).
 2026-03-25 12:29:05 +07:00
Pierre-Olivier Mercier
35fc997390 Add warning banner when all authentication results are missing
All checks were successful
continuous-integration/drone/push Build is passing
Details 
Explains the two most common causes: the mail server not being
configured to verify email authentication, or a receiver hostname
mismatch with --receiver-hostname.

Bug: https://github.com/happyDomain/happydeliver/issues/11
 2026-03-25 12:12:08 +07:00
Pierre-Olivier Mercier
2fcee1b885 Return nil from spam analyzers when primary headers are missing 
Bug: https://github.com/happyDomain/happydeliver/issues/11
 2026-03-25 12:12:08 +07:00
Pierre-Olivier Mercier
26025c96a2 Document --receiver-hostname flag and HAPPYDELIVER_RECEIVER_HOSTNAME env var 
Explain how happyDeliver filters Authentication-Results headers by
hostname, how to find the correct authserv-id value, and when to
override it (especially when bypassing the embedded Postfix).

Bug: https://github.com/happyDomain/happydeliver/issues/1
Bug: https://github.com/happyDomain/happydeliver/issues/11
 2026-03-25 12:12:08 +07:00
Pierre-Olivier Mercier
76ee50a100 Make receiver hostname configurable via --receiver-hostname flag 
Remove the package-level global hostname from parser.go.

Adds a log warning when the last Received hop doesn't match the
expected receiver hostname.

Bug: https://github.com/happyDomain/happydeliver/issues/11
 2026-03-25 12:12:08 +07:00
Pierre-Olivier Mercier
71e0832416 Parse DKIM-Signature headers directly in AnalyzeDNS 
Remove authResults parameter from AnalyzeDNS, making it independent of
the authentication analysis step. Instead, parse DKIM-Signature headers
directly to extract domain and selector.

Bug: https://github.com/happyDomain/happydeliver/issues/11
 2026-03-25 12:12:08 +07:00
Pierre-Olivier Mercier
c96a8b92b8 Readd missing go deps 2026-03-25 12:12:08 +07:00
74 changed files with 9691 additions and 1847 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.gitignore vendored
View file

@ -26,5 +26,5 @@ logs/
*.sqlite3 *.sqlite3
# OpenAPI generated files # OpenAPI generated files
internal/api/models.gen.go
internal/api/server.gen.go internal/api/server.gen.go
internal/model/types.gen.go

3
Dockerfile
View file

@ -175,7 +175,8 @@ ENV HAPPYDELIVER_DATABASE_TYPE=sqlite \
HAPPYDELIVER_DOMAIN=happydeliver.local \ HAPPYDELIVER_DOMAIN=happydeliver.local \
HAPPYDELIVER_ADDRESS_PREFIX=test- \ HAPPYDELIVER_ADDRESS_PREFIX=test- \
HAPPYDELIVER_DNS_TIMEOUT=5s \ HAPPYDELIVER_DNS_TIMEOUT=5s \
HAPPYDELIVER_HTTP_TIMEOUT=10s HAPPYDELIVER_HTTP_TIMEOUT=10s \
HAPPYDELIVER_RSPAMD_API_URL=http://127.0.0.1:11334
# Volume for persistent data # Volume for persistent data
VOLUME ["/var/lib/happydeliver", "/var/log/happydeliver"] VOLUME ["/var/lib/happydeliver", "/var/log/happydeliver"]

46
README.md
View file

@ -166,7 +166,24 @@ The server will start on `http://localhost:8080` by default.
It is expected your setup annotate the email with eg. opendkim, spamassassin, rspamd, ... It is expected your setup annotate the email with eg. opendkim, spamassassin, rspamd, ...
happyDeliver will not perform thoses checks, it relies instead on standard software to have real world annotations. happyDeliver will not perform thoses checks, it relies instead on standard software to have real world annotations.
Choose one of the following way to integrate happyDeliver in your existing setup: #### Receiver Hostname
happyDeliver filters `Authentication-Results` headers by hostname to only trust headers added by your MTA (and not headers that may have been injected by the sender). By default, it uses the system hostname (`os.Hostname()`).
If your MTA's `authserv-id` (the hostname at the beginning of `Authentication-Results` headers) differs from the machine running happyDeliver, you must set it explicitly:
```bash
./happyDeliver server -receiver-hostname mail.example.com
```
Or via environment variable:
```bash
HAPPYDELIVER_RECEIVER_HOSTNAME=mail.example.com ./happyDeliver server
```
**How to find the correct value:** look at the `Authentication-Results` headers in a received email. They start with the authserv-id, e.g. `Authentication-Results: mail.example.com; spf=pass ...` — in this case, use `mail.example.com`.
If the value is misconfigured, happyDeliver will log a warning when the last `Received` hop doesn't match the expected hostname.
#### Postfix LMTP Transport #### Postfix LMTP Transport
@ -262,6 +279,33 @@ cat email.eml | ./happyDeliver analyze -recipient test-uuid@yourdomain.com
**Note:** In production, emails are delivered via LMTP (see integration instructions above). **Note:** In production, emails are delivered via LMTP (see integration instructions above).
## Use with happyDomain
happyDeliver can be driven by [happyDomain](https://happydomain.org) through
the [`checker-happydeliver`](https://git.nemunai.re/happyDomain/checker-happydeliver)
plugin, so the deliverability of a domain you manage is monitored alongside
its DNS and inbound SMTP posture.
How it works:
1. Attach the **Outbound deliverability** checker to the mail service of a zone
in happyDomain. Point it at a happyDeliver instance via `happydeliver_url`;
operators can configure a default instance globally.
2. On each run, the checker calls `POST /api/test` to allocate a fresh
recipient address, prompts the user (or an automated sender) to mail it from
the tested domain, then polls `GET /api/test/{id}` until the report is
ready.
3. The structured report from `GET /api/report/{id}` is translated into
happyDomain rule states: CRIT/WARN/INFO on SPF, DKIM, DMARC, alignment, spam
score, blacklists and headers, plus an overall score threshold
(`min_score`/`warn_score`).
4. Runs repeat on a configurable interval so a regression in deliverability (a
new RBL listing, a DKIM key rotation gone wrong, a broken SPF include, ...)
surfaces as a domain-level alert in happyDomain.
See the [`checker-happydeliver` repository](https://git.nemunai.re/happyDomain/checker-happydeliver)
for build instructions and the full list of run options.
## Scoring System ## Scoring System
The deliverability score is calculated from A to F based on: The deliverability score is calculated from A to F based on:

10
api/config-models.yaml
View file

@ -1,5 +1,9 @@
package: api package: model
generate: generate:
models: true models: true
embedded-spec: false embedded-spec: true
output: internal/api/models.gen.go output: internal/model/types.gen.go
output-options:
skip-prune: true
import-mapping:
./schemas.yaml: "-"

3
api/config-server.yaml
View file

@ -1,5 +1,8 @@
package: api package: api
generate: generate:
gin-server: true gin-server: true
models: true
embedded-spec: true embedded-spec: true
output: internal/api/server.gen.go output: internal/api/server.gen.go
import-mapping:
./schemas.yaml: git.happydns.org/happyDeliver/internal/model

1175
api/openapi.yaml
View file

File diff suppressed because it is too large Load diff

1173
api/schemas.yaml Normal file
View file

File diff suppressed because it is too large Load diff

28
docker/README.md
View file

@ -110,14 +110,38 @@ Default configuration for the Docker environment:
The container accepts these environment variables: The container accepts these environment variables:
- `HAPPYDELIVER_DOMAIN`: Email domain for test addresses (default: happydeliver.local) - `HAPPYDELIVER_DOMAIN`: Email domain for test addresses (default: happydeliver.local)
- `HAPPYDELIVER_RECEIVER_HOSTNAME`: Hostname used to filter `Authentication-Results` headers (see below)
- `POSTFIX_CERT_FILE` / `POSTFIX_KEY_FILE`: TLS certificate and key paths for Postfix SMTP
Note that the hostname of the container is used to filter the authentication tests results. ### Receiver Hostname
Example: happyDeliver filters `Authentication-Results` headers by hostname to only trust results from the expected MTA. By default, it uses the system hostname (i.e., the container's `--hostname`).
In the all-in-one Docker container, the container hostname is also used as the `authserv-id` in the embedded Postfix and authentication_milter, so everything matches automatically.
**When bypassing the embedded Postfix** (e.g., routing emails from your own MTA via LMTP), your MTA's `authserv-id` will likely differ from the container hostname. In that case, set `HAPPYDELIVER_RECEIVER_HOSTNAME` to your MTA's hostname:
```bash
docker run -d \
-e HAPPYDELIVER_DOMAIN=example.com \
-e HAPPYDELIVER_RECEIVER_HOSTNAME=mail.example.com \
...
```
To find the correct value, look at the `Authentication-Results` headers in a received email — they start with the authserv-id, e.g. `Authentication-Results: mail.example.com; spf=pass ...`.
If the value is misconfigured, happyDeliver will log a warning when the last `Received` hop doesn't match the expected hostname.
Example (all-in-one, no override needed):
```bash ```bash
docker run -e HAPPYDELIVER_DOMAIN=example.com --hostname mail.example.com ... docker run -e HAPPYDELIVER_DOMAIN=example.com --hostname mail.example.com ...
``` ```
Example (external MTA integration):
```bash
docker run -e HAPPYDELIVER_DOMAIN=example.com -e HAPPYDELIVER_RECEIVER_HOSTNAME=mail.example.com ...
```
## Volumes ## Volumes
**Required volumes:** **Required volumes:**

2
generate.go
View file

@ -21,5 +21,5 @@
package main package main
//go:generate go tool oapi-codegen -config api/config-models.yaml api/openapi.yaml //go:generate go tool oapi-codegen -config api/config-models.yaml api/schemas.yaml
//go:generate go tool oapi-codegen -config api/config-server.yaml api/openapi.yaml //go:generate go tool oapi-codegen -config api/config-server.yaml api/openapi.yaml

32
go.mod
View file

@ -3,18 +3,20 @@ module git.happydns.org/happyDeliver
go 1.25.0 go 1.25.0
require ( require (
github.com/JGLTechnologies/gin-rate-limit v1.5.6 github.com/JGLTechnologies/gin-rate-limit v1.5.8
github.com/emersion/go-smtp v0.24.0 github.com/emersion/go-smtp v0.24.0
github.com/getkin/kin-openapi v0.135.0
github.com/gin-gonic/gin v1.12.0 github.com/gin-gonic/gin v1.12.0
github.com/google/uuid v1.6.0 github.com/google/uuid v1.6.0
github.com/oapi-codegen/runtime v1.3.0 github.com/oapi-codegen/runtime v1.3.0
golang.org/x/net v0.52.0 golang.org/x/net v0.53.0
gorm.io/driver/postgres v1.6.0 gorm.io/driver/postgres v1.6.0
gorm.io/driver/sqlite v1.6.0 gorm.io/driver/sqlite v1.6.0
gorm.io/gorm v1.31.1 gorm.io/gorm v1.31.1
) )
require ( require (
github.com/apapsch/go-jsonmerge/v2 v2.0.0 // indirect
github.com/bytedance/gopkg v0.1.3 // indirect github.com/bytedance/gopkg v0.1.3 // indirect
github.com/bytedance/sonic v1.15.0 // indirect github.com/bytedance/sonic v1.15.0 // indirect
github.com/bytedance/sonic/loader v0.5.0 // indirect github.com/bytedance/sonic/loader v0.5.0 // indirect
@ -24,7 +26,6 @@ require (
github.com/dprotaso/go-yit v0.0.0-20220510233725-9ba8df137936 // indirect github.com/dprotaso/go-yit v0.0.0-20220510233725-9ba8df137936 // indirect
github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6 // indirect github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6 // indirect
github.com/gabriel-vasile/mimetype v1.4.12 // indirect github.com/gabriel-vasile/mimetype v1.4.12 // indirect
github.com/getkin/kin-openapi v0.133.0 // indirect
github.com/gin-contrib/sse v1.1.0 // indirect github.com/gin-contrib/sse v1.1.0 // indirect
github.com/go-openapi/jsonpointer v0.22.4 // indirect github.com/go-openapi/jsonpointer v0.22.4 // indirect
github.com/go-openapi/swag/jsonname v0.25.4 // indirect github.com/go-openapi/swag/jsonname v0.25.4 // indirect
@ -49,30 +50,31 @@ require (
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
github.com/oapi-codegen/oapi-codegen/v2 v2.5.1 // indirect github.com/oapi-codegen/oapi-codegen/v2 v2.7.0 // indirect
github.com/oasdiff/yaml v0.0.0-20250309154309-f31be36b4037 // indirect github.com/oasdiff/yaml v0.0.9 // indirect
github.com/oasdiff/yaml3 v0.0.0-20250309153720-d2182401db90 // indirect github.com/oasdiff/yaml3 v0.0.9 // indirect
github.com/pelletier/go-toml/v2 v2.2.4 // indirect github.com/pelletier/go-toml/v2 v2.2.4 // indirect
github.com/perimeterx/marshmallow v1.1.5 // indirect github.com/perimeterx/marshmallow v1.1.5 // indirect
github.com/quic-go/qpack v0.6.0 // indirect github.com/quic-go/qpack v0.6.0 // indirect
github.com/quic-go/quic-go v0.59.0 // indirect github.com/quic-go/quic-go v0.59.0 // indirect
github.com/redis/go-redis/v9 v9.17.2 // indirect github.com/redis/go-redis/v9 v9.18.0 // indirect
github.com/speakeasy-api/jsonpath v0.6.0 // indirect github.com/speakeasy-api/jsonpath v0.6.3 // indirect
github.com/speakeasy-api/openapi-overlay v0.10.2 // indirect github.com/speakeasy-api/openapi v1.19.2 // indirect
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
github.com/ugorji/go/codec v1.3.1 // indirect github.com/ugorji/go/codec v1.3.1 // indirect
github.com/vmware-labs/yaml-jsonpath v0.3.2 // indirect github.com/vmware-labs/yaml-jsonpath v0.3.2 // indirect
github.com/woodsbury/decimal128 v1.4.0 // indirect github.com/woodsbury/decimal128 v1.4.0 // indirect
go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect
go.uber.org/atomic v1.11.0 // indirect
go.yaml.in/yaml/v3 v3.0.4 // indirect
golang.org/x/arch v0.23.0 // indirect golang.org/x/arch v0.23.0 // indirect
golang.org/x/crypto v0.49.0 // indirect golang.org/x/crypto v0.50.0 // indirect
golang.org/x/mod v0.33.0 // indirect golang.org/x/mod v0.34.0 // indirect
golang.org/x/sync v0.20.0 // indirect golang.org/x/sync v0.20.0 // indirect
golang.org/x/sys v0.42.0 // indirect golang.org/x/sys v0.43.0 // indirect
golang.org/x/text v0.35.0 // indirect golang.org/x/text v0.36.0 // indirect
golang.org/x/tools v0.42.0 // indirect golang.org/x/tools v0.43.0 // indirect
google.golang.org/protobuf v1.36.11 // indirect google.golang.org/protobuf v1.36.11 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect
) )

78
go.sum
View file

@ -1,5 +1,9 @@
github.com/JGLTechnologies/gin-rate-limit v1.5.6 h1:BrL2wXrF7SSqmB88YTGFVKMGVcjURMUeKqwQrlmzweI= github.com/JGLTechnologies/gin-rate-limit v1.5.8 h1:KiaHIEbpYxHpDvjhpjIif8fnVmjdw/afCMdGoN1AsB0=
github.com/JGLTechnologies/gin-rate-limit v1.5.6/go.mod h1:fwUuBegxLKm8+/4ST0zDFssRFTFaVZ7bH3ApK7iNZww= github.com/JGLTechnologies/gin-rate-limit v1.5.8/go.mod h1:t9eLOUxikPI0TzKy0VYRbZJr7hBP2Qg9E3JigoxF70g=
github.com/RaveNoX/go-jsoncommentstrip v1.0.0/go.mod h1:78ihd09MekBnJnxpICcwzCMzGrKSKYe4AqU6PDYYpjk=
github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ=
github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk=
github.com/bmatcuk/doublestar v1.1.1/go.mod h1:UD6OnuiIn0yFxxA2le/rnRU1G4RaI4UvFv1sNto9p6w=
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
@ -18,8 +22,9 @@ github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMn
github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M= github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M=
github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU= github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
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/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
github.com/dprotaso/go-yit v0.0.0-20191028211022-135eb7262960/go.mod h1:9HQzr9D/0PGwMEbC3d5AB7oi67+h4TsQqItC1GVYG58= github.com/dprotaso/go-yit v0.0.0-20191028211022-135eb7262960/go.mod h1:9HQzr9D/0PGwMEbC3d5AB7oi67+h4TsQqItC1GVYG58=
@ -34,8 +39,8 @@ github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWo
github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
github.com/gabriel-vasile/mimetype v1.4.12 h1:e9hWvmLYvtp846tLHam2o++qitpguFiYCKbn0w9jyqw= github.com/gabriel-vasile/mimetype v1.4.12 h1:e9hWvmLYvtp846tLHam2o++qitpguFiYCKbn0w9jyqw=
github.com/gabriel-vasile/mimetype v1.4.12/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s= github.com/gabriel-vasile/mimetype v1.4.12/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
github.com/getkin/kin-openapi v0.133.0 h1:pJdmNohVIJ97r4AUFtEXRXwESr8b0bD721u/Tz6k8PQ= github.com/getkin/kin-openapi v0.135.0 h1:751SjYfbiwqukYuVjwYEIKNfrSwS5YpA7DZnKSwQgtg=
github.com/getkin/kin-openapi v0.133.0/go.mod h1:boAciF6cXk5FhPqe/NQeBTeenbjqU4LhWBf09ILVvWE= github.com/getkin/kin-openapi v0.135.0/go.mod h1:6dd5FJl6RdX4usBtFBaQhk9q62Yb2J0Mk5IhUO/QqFI=
github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w= github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM= github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
github.com/gin-gonic/gin v1.12.0 h1:b3YAbrZtnf8N//yjKeU2+MQsh2mY5htkZidOM7O0wG8= github.com/gin-gonic/gin v1.12.0 h1:b3YAbrZtnf8N//yjKeU2+MQsh2mY5htkZidOM7O0wG8=
@ -98,6 +103,7 @@ github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8Hm
github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/juju/gnuflag v0.0.0-20171113085948-2ce1bb71843d/go.mod h1:2PavIy+JPciBPrBUjwbNvtwB6RQlve+hkpll6QSNmOE=
github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y= github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@ -125,14 +131,14 @@ github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwd
github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
github.com/oapi-codegen/oapi-codegen/v2 v2.5.1 h1:5vHNY1uuPBRBWqB2Dp0G7YB03phxLQZupZTIZaeorjc= github.com/oapi-codegen/oapi-codegen/v2 v2.7.0 h1:/8daqIYZfwnsHEAZdHUu9m0D5LA+5DoJCP7zLlT5Cs0=
github.com/oapi-codegen/oapi-codegen/v2 v2.5.1/go.mod h1:ro0npU1BWkcGpCgGD9QwPp44l5OIZ94tB3eabnT7DjQ= github.com/oapi-codegen/oapi-codegen/v2 v2.7.0/go.mod h1:qzFy6iuobJw/hD1aRILee4G87/ShmhR0xYCwcUtZMCw=
github.com/oapi-codegen/runtime v1.3.0 h1:vyK1zc0gDWWXgk2xoQa4+X4RNNc5SL2RbTpJS/4vMYA= github.com/oapi-codegen/runtime v1.3.0 h1:vyK1zc0gDWWXgk2xoQa4+X4RNNc5SL2RbTpJS/4vMYA=
github.com/oapi-codegen/runtime v1.3.0/go.mod h1:kOdeacKy7t40Rclb1je37ZLFboFxh+YLy0zaPCMibPY= github.com/oapi-codegen/runtime v1.3.0/go.mod h1:kOdeacKy7t40Rclb1je37ZLFboFxh+YLy0zaPCMibPY=
github.com/oasdiff/yaml v0.0.0-20250309154309-f31be36b4037 h1:G7ERwszslrBzRxj//JalHPu/3yz+De2J+4aLtSRlHiY= github.com/oasdiff/yaml v0.0.9 h1:zQOvd2UKoozsSsAknnWoDJlSK4lC0mpmjfDsfqNwX48=
github.com/oasdiff/yaml v0.0.0-20250309154309-f31be36b4037/go.mod h1:2bpvgLBZEtENV5scfDFEtB/5+1M4hkQhDQrccEJ/qGw= github.com/oasdiff/yaml v0.0.9/go.mod h1:8lvhgJG4xiKPj3HN5lDow4jZHPlx1i7dIwzkdAo6oAM=
github.com/oasdiff/yaml3 v0.0.0-20250309153720-d2182401db90 h1:bQx3WeLcUWy+RletIKwUIt4x3t8n2SxavmoclizMb8c= github.com/oasdiff/yaml3 v0.0.9 h1:rWPrKccrdUm8J0F3sGuU+fuh9+1K/RdJlWF7O/9yw2g=
github.com/oasdiff/yaml3 v0.0.0-20250309153720-d2182401db90/go.mod h1:y5+oSEHCPT/DGrS++Wc/479ERge0zTFxaF8PbGKcg2o= github.com/oasdiff/yaml3 v0.0.9/go.mod h1:y5+oSEHCPT/DGrS++Wc/479ERge0zTFxaF8PbGKcg2o=
github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.10.2/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.10.2/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
@ -149,22 +155,24 @@ github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0
github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
github.com/perimeterx/marshmallow v1.1.5 h1:a2LALqQ1BlHM8PZblsDdidgv1mWi1DgC2UmX50IvK2s= github.com/perimeterx/marshmallow v1.1.5 h1:a2LALqQ1BlHM8PZblsDdidgv1mWi1DgC2UmX50IvK2s=
github.com/perimeterx/marshmallow v1.1.5/go.mod h1:dsXbUu8CRzfYP5a87xpp0xq9S3u0Vchtcl8we9tYaXw= github.com/perimeterx/marshmallow v1.1.5/go.mod h1:dsXbUu8CRzfYP5a87xpp0xq9S3u0Vchtcl8we9tYaXw=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8= github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII= github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
github.com/quic-go/quic-go v0.59.0 h1:OLJkp1Mlm/aS7dpKgTc6cnpynnD2Xg7C1pwL6vy/SAw= github.com/quic-go/quic-go v0.59.0 h1:OLJkp1Mlm/aS7dpKgTc6cnpynnD2Xg7C1pwL6vy/SAw=
github.com/quic-go/quic-go v0.59.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU= github.com/quic-go/quic-go v0.59.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU=
github.com/redis/go-redis/v9 v9.17.2 h1:P2EGsA4qVIM3Pp+aPocCJ7DguDHhqrXNhVcEp4ViluI= github.com/redis/go-redis/v9 v9.18.0 h1:pMkxYPkEbMPwRdenAzUNyFNrDgHx9U+DrBabWNfSRQs=
github.com/redis/go-redis/v9 v9.17.2/go.mod h1:u410H11HMLoB+TP67dz8rL9s6QW2j76l0//kSOd3370= github.com/redis/go-redis/v9 v9.18.0/go.mod h1:k3ufPphLU5YXwNTUcCRXGxUoF1fqxnhFQmscfkCoDA0=
github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0= github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=
github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM= github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
github.com/speakeasy-api/jsonpath v0.6.0 h1:IhtFOV9EbXplhyRqsVhHoBmmYjblIRh5D1/g8DHMXJ8= github.com/speakeasy-api/jsonpath v0.6.3 h1:c+QPwzAOdrWvzycuc9HFsIZcxKIaWcNpC+xhOW9rJxU=
github.com/speakeasy-api/jsonpath v0.6.0/go.mod h1:ymb2iSkyOycmzKwbEAYPJV/yi2rSmvBCLZJcyD+VVWw= github.com/speakeasy-api/jsonpath v0.6.3/go.mod h1:2cXloNuQ+RSXi5HTRaeBh7JEmjRXTiaKpFTdZiL7URI=
github.com/speakeasy-api/openapi-overlay v0.10.2 h1:VOdQ03eGKeiHnpb1boZCGm7x8Haj6gST0P3SGTX95GU= github.com/speakeasy-api/openapi v1.19.2 h1:md90tE71/M8jS3cuRlsuWP5Aed4xoG5PSRvXeZgCv/M=
github.com/speakeasy-api/openapi-overlay v0.10.2/go.mod h1:n0iOU7AqKpNFfEt6tq7qYITC4f0yzVVdFw0S7hukemg= github.com/speakeasy-api/openapi v1.19.2/go.mod h1:UfKa7FqE4jgexJZuj51MmdHAFGmDv0Zaw3+yOd81YKU=
github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@ -188,20 +196,26 @@ github.com/vmware-labs/yaml-jsonpath v0.3.2/go.mod h1:U6whw1z03QyqgWdgXxvVnQ90zN
github.com/woodsbury/decimal128 v1.4.0 h1:xJATj7lLu4f2oObouMt2tgGiElE5gO6mSWUjQsBgUlc= github.com/woodsbury/decimal128 v1.4.0 h1:xJATj7lLu4f2oObouMt2tgGiElE5gO6mSWUjQsBgUlc=
github.com/woodsbury/decimal128 v1.4.0/go.mod h1:BP46FUrVjVhdTbKT+XuQh2xfQaGki9LMIRJSFuh6THU= github.com/woodsbury/decimal128 v1.4.0/go.mod h1:BP46FUrVjVhdTbKT+XuQh2xfQaGki9LMIRJSFuh6THU=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE= go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE=
go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0= go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0=
go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU=
go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
golang.org/x/arch v0.23.0 h1:lKF64A2jF6Zd8L0knGltUnegD62JMFBiCPBmQpToHhg= golang.org/x/arch v0.23.0 h1:lKF64A2jF6Zd8L0knGltUnegD62JMFBiCPBmQpToHhg=
golang.org/x/arch v0.23.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A= golang.org/x/arch v0.23.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4= golang.org/x/crypto v0.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI=
golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA= golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q=
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8= golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI=
golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w= golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY=
golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= 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-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@ -209,8 +223,8 @@ golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0= golang.org/x/net v0.53.0 h1:d+qAbo5L0orcWAr0a9JweQpjXF19LMXJE8Ey7hwOdUA=
golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw= golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs=
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@ -231,21 +245,21 @@ golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7w
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo= golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/sys v0.43.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-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.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= 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.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8= golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA= golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= 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.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k= golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s=
golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0= golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

164
internal/api/handlers.go
View file

@ -31,6 +31,7 @@ import (
openapi_types "github.com/oapi-codegen/runtime/types" openapi_types "github.com/oapi-codegen/runtime/types"
"git.happydns.org/happyDeliver/internal/config" "git.happydns.org/happyDeliver/internal/config"
"git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/storage" "git.happydns.org/happyDeliver/internal/storage"
"git.happydns.org/happyDeliver/internal/utils" "git.happydns.org/happyDeliver/internal/utils"
"git.happydns.org/happyDeliver/internal/version" "git.happydns.org/happyDeliver/internal/version"
@ -40,8 +41,8 @@ import (
// This interface breaks the circular dependency with pkg/analyzer // This interface breaks the circular dependency with pkg/analyzer
type EmailAnalyzer interface { type EmailAnalyzer interface {
AnalyzeEmailBytes(rawEmail []byte, testID uuid.UUID) (reportJSON []byte, err error) AnalyzeEmailBytes(rawEmail []byte, testID uuid.UUID) (reportJSON []byte, err error)
AnalyzeDomain(domain string) (dnsResults *DNSResults, score int, grade string) AnalyzeDomain(domain string) (dnsResults *model.DNSResults, score int, grade string)
CheckBlacklistIP(ip string) (checks []BlacklistCheck, whitelists []BlacklistCheck, listedCount int, score int, grade string, err error) CheckBlacklistIP(ip string) (checks []model.BlacklistCheck, whitelists []model.BlacklistCheck, listedCount int, score int, grade string, err error)
} }
// APIHandler implements the ServerInterface for handling API requests // APIHandler implements the ServerInterface for handling API requests
@ -79,11 +80,11 @@ func (h *APIHandler) CreateTest(c *gin.Context) {
) )
// Return response // Return response
c.JSON(http.StatusCreated, TestResponse{ c.JSON(http.StatusCreated, model.TestResponse{
Id: base32ID, Id: base32ID,
Email: openapi_types.Email(email), Email: openapi_types.Email(email),
Status: TestResponseStatusPending, Status: model.TestResponseStatusPending,
Message: stringPtr("Send your test email to the given address"), Message: utils.PtrTo("Send your test email to the given address"),
}) })
} }
@ -93,10 +94,10 @@ func (h *APIHandler) GetTest(c *gin.Context, id string) {
// Convert base32 ID to UUID // Convert base32 ID to UUID
testUUID, err := utils.Base32ToUUID(id) testUUID, err := utils.Base32ToUUID(id)
if err != nil { if err != nil {
c.JSON(http.StatusBadRequest, Error{ c.JSON(http.StatusBadRequest, model.Error{
Error: "invalid_id", Error: "invalid_id",
Message: "Invalid test ID format", Message: "Invalid test ID format",
Details: stringPtr(err.Error()), Details: utils.PtrTo(err.Error()),
}) })
return return
} }
@ -104,20 +105,20 @@ func (h *APIHandler) GetTest(c *gin.Context, id string) {
// Check if a report exists for this test ID // Check if a report exists for this test ID
reportExists, err := h.storage.ReportExists(testUUID) reportExists, err := h.storage.ReportExists(testUUID)
if err != nil { if err != nil {
c.JSON(http.StatusInternalServerError, Error{ c.JSON(http.StatusInternalServerError, model.Error{
Error: "internal_error", Error: "internal_error",
Message: "Failed to check test status", Message: "Failed to check test status",
Details: stringPtr(err.Error()), Details: utils.PtrTo(err.Error()),
}) })
return return
} }
// Determine status based on report existence // Determine status based on report existence
var apiStatus TestStatus var apiStatus model.TestStatus
if reportExists { if reportExists {
apiStatus = TestStatusAnalyzed apiStatus = model.TestStatusAnalyzed
} else { } else {
apiStatus = TestStatusPending apiStatus = model.TestStatusPending
} }
// Generate test email address using Base32-encoded UUID // Generate test email address using Base32-encoded UUID
@ -127,7 +128,7 @@ func (h *APIHandler) GetTest(c *gin.Context, id string) {
h.config.Email.Domain, h.config.Email.Domain,
) )
c.JSON(http.StatusOK, Test{ c.JSON(http.StatusOK, model.Test{
Id: id, Id: id,
Email: openapi_types.Email(email), Email: openapi_types.Email(email),
Status: apiStatus, Status: apiStatus,
@ -140,10 +141,10 @@ func (h *APIHandler) GetReport(c *gin.Context, id string) {
// Convert base32 ID to UUID // Convert base32 ID to UUID
testUUID, err := utils.Base32ToUUID(id) testUUID, err := utils.Base32ToUUID(id)
if err != nil { if err != nil {
c.JSON(http.StatusBadRequest, Error{ c.JSON(http.StatusBadRequest, model.Error{
Error: "invalid_id", Error: "invalid_id",
Message: "Invalid test ID format", Message: "Invalid test ID format",
Details: stringPtr(err.Error()), Details: utils.PtrTo(err.Error()),
}) })
return return
} }
@ -151,16 +152,16 @@ func (h *APIHandler) GetReport(c *gin.Context, id string) {
reportJSON, _, err := h.storage.GetReport(testUUID) reportJSON, _, err := h.storage.GetReport(testUUID)
if err != nil { if err != nil {
if err == storage.ErrNotFound { if err == storage.ErrNotFound {
c.JSON(http.StatusNotFound, Error{ c.JSON(http.StatusNotFound, model.Error{
Error: "not_found", Error: "not_found",
Message: "Report not found", Message: "Report not found",
}) })
return return
} }
c.JSON(http.StatusInternalServerError, Error{ c.JSON(http.StatusInternalServerError, model.Error{
Error: "internal_error", Error: "internal_error",
Message: "Failed to retrieve report", Message: "Failed to retrieve report",
Details: stringPtr(err.Error()), Details: utils.PtrTo(err.Error()),
}) })
return return
} }
@ -175,10 +176,10 @@ func (h *APIHandler) GetRawEmail(c *gin.Context, id string) {
// Convert base32 ID to UUID // Convert base32 ID to UUID
testUUID, err := utils.Base32ToUUID(id) testUUID, err := utils.Base32ToUUID(id)
if err != nil { if err != nil {
c.JSON(http.StatusBadRequest, Error{ c.JSON(http.StatusBadRequest, model.Error{
Error: "invalid_id", Error: "invalid_id",
Message: "Invalid test ID format", Message: "Invalid test ID format",
Details: stringPtr(err.Error()), Details: utils.PtrTo(err.Error()),
}) })
return return
} }
@ -186,16 +187,16 @@ func (h *APIHandler) GetRawEmail(c *gin.Context, id string) {
_, rawEmail, err := h.storage.GetReport(testUUID) _, rawEmail, err := h.storage.GetReport(testUUID)
if err != nil { if err != nil {
if err == storage.ErrNotFound { if err == storage.ErrNotFound {
c.JSON(http.StatusNotFound, Error{ c.JSON(http.StatusNotFound, model.Error{
Error: "not_found", Error: "not_found",
Message: "Email not found", Message: "Email not found",
}) })
return return
} }
c.JSON(http.StatusInternalServerError, Error{ c.JSON(http.StatusInternalServerError, model.Error{
Error: "internal_error", Error: "internal_error",
Message: "Failed to retrieve raw email", Message: "Failed to retrieve raw email",
Details: stringPtr(err.Error()), Details: utils.PtrTo(err.Error()),
}) })
return return
} }
@ -209,10 +210,10 @@ func (h *APIHandler) ReanalyzeReport(c *gin.Context, id string) {
// Convert base32 ID to UUID // Convert base32 ID to UUID
testUUID, err := utils.Base32ToUUID(id) testUUID, err := utils.Base32ToUUID(id)
if err != nil { if err != nil {
c.JSON(http.StatusBadRequest, Error{ c.JSON(http.StatusBadRequest, model.Error{
Error: "invalid_id", Error: "invalid_id",
Message: "Invalid test ID format", Message: "Invalid test ID format",
Details: stringPtr(err.Error()), Details: utils.PtrTo(err.Error()),
}) })
return return
} }
@ -221,16 +222,16 @@ func (h *APIHandler) ReanalyzeReport(c *gin.Context, id string) {
_, rawEmail, err := h.storage.GetReport(testUUID) _, rawEmail, err := h.storage.GetReport(testUUID)
if err != nil { if err != nil {
if err == storage.ErrNotFound { if err == storage.ErrNotFound {
c.JSON(http.StatusNotFound, Error{ c.JSON(http.StatusNotFound, model.Error{
Error: "not_found", Error: "not_found",
Message: "Email not found", Message: "Email not found",
}) })
return return
} }
c.JSON(http.StatusInternalServerError, Error{ c.JSON(http.StatusInternalServerError, model.Error{
Error: "internal_error", Error: "internal_error",
Message: "Failed to retrieve email", Message: "Failed to retrieve email",
Details: stringPtr(err.Error()), Details: utils.PtrTo(err.Error()),
}) })
return return
} }
@ -238,20 +239,20 @@ func (h *APIHandler) ReanalyzeReport(c *gin.Context, id string) {
// Re-analyze the email using the current analyzer // Re-analyze the email using the current analyzer
reportJSON, err := h.analyzer.AnalyzeEmailBytes(rawEmail, testUUID) reportJSON, err := h.analyzer.AnalyzeEmailBytes(rawEmail, testUUID)
if err != nil { if err != nil {
c.JSON(http.StatusInternalServerError, Error{ c.JSON(http.StatusInternalServerError, model.Error{
Error: "analysis_error", Error: "analysis_error",
Message: "Failed to re-analyze email", Message: "Failed to re-analyze email",
Details: stringPtr(err.Error()), Details: utils.PtrTo(err.Error()),
}) })
return return
} }
// Update the report in storage // Update the report in storage
if err := h.storage.UpdateReport(testUUID, reportJSON); err != nil { if err := h.storage.UpdateReport(testUUID, reportJSON); err != nil {
c.JSON(http.StatusInternalServerError, Error{ c.JSON(http.StatusInternalServerError, model.Error{
Error: "internal_error", Error: "internal_error",
Message: "Failed to update report", Message: "Failed to update report",
Details: stringPtr(err.Error()), Details: utils.PtrTo(err.Error()),
}) })
return return
} }
@ -267,24 +268,24 @@ func (h *APIHandler) GetStatus(c *gin.Context) {
uptime := int(time.Since(h.startTime).Seconds()) uptime := int(time.Since(h.startTime).Seconds())
// Check database connectivity by trying to check if a report exists // Check database connectivity by trying to check if a report exists
dbStatus := StatusComponentsDatabaseUp dbStatus := model.StatusComponentsDatabaseUp
if _, err := h.storage.ReportExists(uuid.New()); err != nil { if _, err := h.storage.ReportExists(uuid.New()); err != nil {
dbStatus = StatusComponentsDatabaseDown dbStatus = model.StatusComponentsDatabaseDown
} }
// Determine overall status // Determine overall status
overallStatus := Healthy overallStatus := model.Healthy
if dbStatus == StatusComponentsDatabaseDown { if dbStatus == model.StatusComponentsDatabaseDown {
overallStatus = Unhealthy overallStatus = model.Unhealthy
} }
mtaStatus := StatusComponentsMtaUp mtaStatus := model.StatusComponentsMtaUp
c.JSON(http.StatusOK, Status{ c.JSON(http.StatusOK, model.Status{
Status: overallStatus, Status: overallStatus,
Version: version.Version, Version: version.Version,
Components: &struct { Components: &struct {
Database *StatusComponentsDatabase `json:"database,omitempty"` Database *model.StatusComponentsDatabase `json:"database,omitempty"`
Mta *StatusComponentsMta `json:"mta,omitempty"` Mta *model.StatusComponentsMta `json:"mta,omitempty"`
}{ }{
Database: &dbStatus, Database: &dbStatus,
Mta: &mtaStatus, Mta: &mtaStatus,
@ -296,14 +297,14 @@ func (h *APIHandler) GetStatus(c *gin.Context) {
// TestDomain performs synchronous domain analysis // TestDomain performs synchronous domain analysis
// (POST /domain) // (POST /domain)
func (h *APIHandler) TestDomain(c *gin.Context) { func (h *APIHandler) TestDomain(c *gin.Context) {
var request DomainTestRequest var request model.DomainTestRequest
// Bind and validate request // Bind and validate request
if err := c.ShouldBindJSON(&request); err != nil { if err := c.ShouldBindJSON(&request); err != nil {
c.JSON(http.StatusBadRequest, Error{ c.JSON(http.StatusBadRequest, model.Error{
Error: "invalid_request", Error: "invalid_request",
Message: "Invalid request body", Message: "Invalid request body",
Details: stringPtr(err.Error()), Details: utils.PtrTo(err.Error()),
}) })
return return
} }
@ -312,28 +313,28 @@ func (h *APIHandler) TestDomain(c *gin.Context) {
dnsResults, score, grade := h.analyzer.AnalyzeDomain(request.Domain) dnsResults, score, grade := h.analyzer.AnalyzeDomain(request.Domain)
// Convert grade string to DomainTestResponseGrade enum // Convert grade string to DomainTestResponseGrade enum
var responseGrade DomainTestResponseGrade var responseGrade model.DomainTestResponseGrade
switch grade { switch grade {
case "A+": case "A+":
responseGrade = DomainTestResponseGradeA responseGrade = model.DomainTestResponseGradeA
case "A": case "A":
responseGrade = DomainTestResponseGradeA1 responseGrade = model.DomainTestResponseGradeA1
case "B": case "B":
responseGrade = DomainTestResponseGradeB responseGrade = model.DomainTestResponseGradeB
case "C": case "C":
responseGrade = DomainTestResponseGradeC responseGrade = model.DomainTestResponseGradeC
case "D": case "D":
responseGrade = DomainTestResponseGradeD responseGrade = model.DomainTestResponseGradeD
case "E": case "E":
responseGrade = DomainTestResponseGradeE responseGrade = model.DomainTestResponseGradeE
case "F": case "F":
responseGrade = DomainTestResponseGradeF responseGrade = model.DomainTestResponseGradeF
default: default:
responseGrade = DomainTestResponseGradeF responseGrade = model.DomainTestResponseGradeF
} }
// Build response // Build response
response := DomainTestResponse{ response := model.DomainTestResponse{
Domain: request.Domain, Domain: request.Domain,
Score: score, Score: score,
Grade: responseGrade, Grade: responseGrade,
@ -346,14 +347,14 @@ func (h *APIHandler) TestDomain(c *gin.Context) {
// CheckBlacklist checks an IP address against DNS blacklists // CheckBlacklist checks an IP address against DNS blacklists
// (POST /blacklist) // (POST /blacklist)
func (h *APIHandler) CheckBlacklist(c *gin.Context) { func (h *APIHandler) CheckBlacklist(c *gin.Context) {
var request BlacklistCheckRequest var request model.BlacklistCheckRequest
// Bind and validate request // Bind and validate request
if err := c.ShouldBindJSON(&request); err != nil { if err := c.ShouldBindJSON(&request); err != nil {
c.JSON(http.StatusBadRequest, Error{ c.JSON(http.StatusBadRequest, model.Error{
Error: "invalid_request", Error: "invalid_request",
Message: "Invalid request body", Message: "Invalid request body",
Details: stringPtr(err.Error()), Details: utils.PtrTo(err.Error()),
}) })
return return
} }
@ -361,23 +362,64 @@ func (h *APIHandler) CheckBlacklist(c *gin.Context) {
// Perform blacklist check using analyzer // Perform blacklist check using analyzer
checks, whitelists, listedCount, score, grade, err := h.analyzer.CheckBlacklistIP(request.Ip) checks, whitelists, listedCount, score, grade, err := h.analyzer.CheckBlacklistIP(request.Ip)
if err != nil { if err != nil {
c.JSON(http.StatusBadRequest, Error{ c.JSON(http.StatusBadRequest, model.Error{
Error: "invalid_ip", Error: "invalid_ip",
Message: "Invalid IP address", Message: "Invalid IP address",
Details: stringPtr(err.Error()), Details: utils.PtrTo(err.Error()),
}) })
return return
} }
// Build response // Build response
response := BlacklistCheckResponse{ response := model.BlacklistCheckResponse{
Ip: request.Ip, Ip: request.Ip,
Blacklists: checks, Blacklists: checks,
Whitelists: &whitelists, Whitelists: &whitelists,
ListedCount: listedCount, ListedCount: listedCount,
Score: score, Score: score,
Grade: BlacklistCheckResponseGrade(grade), Grade: model.BlacklistCheckResponseGrade(grade),
} }
c.JSON(http.StatusOK, response) c.JSON(http.StatusOK, response)
} }
// ListTests returns a paginated list of test summaries
// (GET /tests)
func (h *APIHandler) ListTests(c *gin.Context, params ListTestsParams) {
if h.config.DisableTestList {
c.JSON(http.StatusForbidden, model.Error{
Error: "feature_disabled",
Message: "Test listing is disabled on this instance",
})
return
}
offset := 0
limit := 20
if params.Offset != nil {
offset = *params.Offset
}
if params.Limit != nil {
limit = *params.Limit
if limit > 100 {
limit = 100
}
}
tests, total, err := h.storage.ListReportSummaries(offset, limit)
if err != nil {
c.JSON(http.StatusInternalServerError, model.Error{
Error: "internal_error",
Message: "Failed to list tests",
Details: utils.PtrTo(err.Error()),
})
return
}
c.JSON(http.StatusOK, model.TestListResponse{
Tests: tests,
Total: int(total),
Offset: offset,
Limit: limit,
})
}

3
internal/config/cli.go
View file

@ -34,14 +34,17 @@ func declareFlags(o *Config) {
flag.StringVar(&o.Email.Domain, "domain", o.Email.Domain, "Domain used to receive emails") flag.StringVar(&o.Email.Domain, "domain", o.Email.Domain, "Domain used to receive emails")
flag.StringVar(&o.Email.TestAddressPrefix, "address-prefix", o.Email.TestAddressPrefix, "Expected email adress prefix (deny address that doesn't start with this prefix)") flag.StringVar(&o.Email.TestAddressPrefix, "address-prefix", o.Email.TestAddressPrefix, "Expected email adress prefix (deny address that doesn't start with this prefix)")
flag.StringVar(&o.Email.LMTPAddr, "lmtp-addr", o.Email.LMTPAddr, "LMTP server listen address") flag.StringVar(&o.Email.LMTPAddr, "lmtp-addr", o.Email.LMTPAddr, "LMTP server listen address")
flag.StringVar(&o.Email.ReceiverHostname, "receiver-hostname", o.Email.ReceiverHostname, "Hostname used to filter Authentication-Results headers (defaults to os.Hostname())")
flag.DurationVar(&o.Analysis.DNSTimeout, "dns-timeout", o.Analysis.DNSTimeout, "Timeout when performing DNS query") flag.DurationVar(&o.Analysis.DNSTimeout, "dns-timeout", o.Analysis.DNSTimeout, "Timeout when performing DNS query")
flag.DurationVar(&o.Analysis.HTTPTimeout, "http-timeout", o.Analysis.HTTPTimeout, "Timeout when performing HTTP query") flag.DurationVar(&o.Analysis.HTTPTimeout, "http-timeout", o.Analysis.HTTPTimeout, "Timeout when performing HTTP query")
flag.Var(&StringArray{&o.Analysis.RBLs}, "rbl", "Append a RBL (use this option multiple time to append multiple RBLs)") flag.Var(&StringArray{&o.Analysis.RBLs}, "rbl", "Append a RBL (use this option multiple time to append multiple RBLs)")
flag.BoolVar(&o.Analysis.CheckAllIPs, "check-all-ips", o.Analysis.CheckAllIPs, "Check all IPs found in email headers against RBLs (not just the first one)") flag.BoolVar(&o.Analysis.CheckAllIPs, "check-all-ips", o.Analysis.CheckAllIPs, "Check all IPs found in email headers against RBLs (not just the first one)")
flag.StringVar(&o.Analysis.RspamdAPIURL, "rspamd-api-url", o.Analysis.RspamdAPIURL, "rspamd API URL for symbol descriptions (default: use embedded list)")
flag.DurationVar(&o.ReportRetention, "report-retention", o.ReportRetention, "How long to keep reports (e.g., 720h, 30d). 0 = keep forever") flag.DurationVar(&o.ReportRetention, "report-retention", o.ReportRetention, "How long to keep reports (e.g., 720h, 30d). 0 = keep forever")
flag.UintVar(&o.RateLimit, "rate-limit", o.RateLimit, "API rate limit (requests per second per IP)") flag.UintVar(&o.RateLimit, "rate-limit", o.RateLimit, "API rate limit (requests per second per IP)")
flag.Var(&URL{&o.SurveyURL}, "survey-url", "URL for user feedback survey") flag.Var(&URL{&o.SurveyURL}, "survey-url", "URL for user feedback survey")
flag.StringVar(&o.CustomLogoURL, "custom-logo-url", o.CustomLogoURL, "URL for custom logo image in the web UI") flag.StringVar(&o.CustomLogoURL, "custom-logo-url", o.CustomLogoURL, "URL for custom logo image in the web UI")
flag.BoolVar(&o.DisableTestList, "disable-test-list", o.DisableTestList, "Disable the public test listing endpoint")
// Others flags are declared in some other files likes sources, storages, ... when they need specials configurations // Others flags are declared in some other files likes sources, storages, ... when they need specials configurations
} }

11
internal/config/config.go
View file

@ -34,6 +34,11 @@ import (
openapi_types "github.com/oapi-codegen/runtime/types" openapi_types "github.com/oapi-codegen/runtime/types"
) )
func getHostname() string {
h, _ := os.Hostname()
return h
}
// Config represents the application configuration // Config represents the application configuration
type Config struct { type Config struct {
DevProxy string DevProxy string
@ -45,6 +50,7 @@ type Config struct {
RateLimit uint // API rate limit (requests per second per IP) RateLimit uint // API rate limit (requests per second per IP)
SurveyURL url.URL // URL for user feedback survey SurveyURL url.URL // URL for user feedback survey
CustomLogoURL string // URL for custom logo image in the web UI CustomLogoURL string // URL for custom logo image in the web UI
DisableTestList bool // Disable the public test listing endpoint
} }
// DatabaseConfig contains database connection settings // DatabaseConfig contains database connection settings
@ -58,6 +64,7 @@ type EmailConfig struct {
Domain string Domain string
TestAddressPrefix string TestAddressPrefix string
LMTPAddr string LMTPAddr string
ReceiverHostname string
} }
// AnalysisConfig contains timeout and behavior settings for email analysis // AnalysisConfig contains timeout and behavior settings for email analysis
@ -66,7 +73,8 @@ type AnalysisConfig struct {
HTTPTimeout time.Duration HTTPTimeout time.Duration
RBLs []string RBLs []string
DNSWLs []string DNSWLs []string
CheckAllIPs bool // Check all IPs found in headers, not just the first one CheckAllIPs bool // Check all IPs found in headers, not just the first one
RspamdAPIURL string // rspamd API URL for fetching symbol descriptions (empty = use embedded list)
} }
// DefaultConfig returns a configuration with sensible defaults // DefaultConfig returns a configuration with sensible defaults
@ -84,6 +92,7 @@ func DefaultConfig() *Config {
Domain: "happydeliver.local", Domain: "happydeliver.local",
TestAddressPrefix: "test-", TestAddressPrefix: "test-",
LMTPAddr: "127.0.0.1:2525", LMTPAddr: "127.0.0.1:2525",
ReceiverHostname: getHostname(),
}, },
Analysis: AnalysisConfig{ Analysis: AnalysisConfig{
DNSTimeout: 5 * time.Second, DNSTimeout: 5 * time.Second,

11
internal/receiver/receiver.go
View file

@ -98,6 +98,17 @@ func (r *EmailReceiver) ProcessEmailBytes(rawEmail []byte, recipientEmail string
log.Printf("Analysis complete. Grade: %s. Score: %d/100", result.Report.Grade, result.Report.Score) log.Printf("Analysis complete. Grade: %s. Score: %d/100", result.Report.Grade, result.Report.Score)
// Warn if the last Received hop doesn't match the expected receiver hostname
if r.config.Email.ReceiverHostname != "" &&
result.Report.HeaderAnalysis != nil &&
result.Report.HeaderAnalysis.ReceivedChain != nil &&
len(*result.Report.HeaderAnalysis.ReceivedChain) > 0 {
lastHop := (*result.Report.HeaderAnalysis.ReceivedChain)[0]
if lastHop.By != nil && *lastHop.By != r.config.Email.ReceiverHostname {
log.Printf("WARNING: Last Received hop 'by' field (%s) does not match expected receiver hostname (%s): check your RECEIVER_HOSTNAME config as authentication results will be false", *lastHop.By, r.config.Email.ReceiverHostname)
}
}
// Marshal report to JSON // Marshal report to JSON
reportJSON, err := json.Marshal(result.Report) reportJSON, err := json.Marshal(result.Report)
if err != nil { if err != nil {

70
internal/storage/storage.go
View file

@ -30,6 +30,9 @@ import (
"gorm.io/driver/postgres" "gorm.io/driver/postgres"
"gorm.io/driver/sqlite" "gorm.io/driver/sqlite"
"gorm.io/gorm" "gorm.io/gorm"
"git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
var ( var (
@ -45,6 +48,7 @@ type Storage interface {
ReportExists(testID uuid.UUID) (bool, error) ReportExists(testID uuid.UUID) (bool, error)
UpdateReport(testID uuid.UUID, reportJSON []byte) error UpdateReport(testID uuid.UUID, reportJSON []byte) error
DeleteOldReports(olderThan time.Time) (int64, error) DeleteOldReports(olderThan time.Time) (int64, error)
ListReportSummaries(offset, limit int) ([]model.TestSummary, int64, error)
// Close closes the database connection // Close closes the database connection
Close() error Close() error
@ -139,6 +143,72 @@ func (s *DBStorage) DeleteOldReports(olderThan time.Time) (int64, error) {
return result.RowsAffected, nil return result.RowsAffected, nil
} }
// reportSummaryRow is used internally to scan SQL results before converting to model.TestSummary
type reportSummaryRow struct {
TestID uuid.UUID
Score int
Grade string
FromDomain string
CreatedAt time.Time
}
// ListReportSummaries returns a paginated list of lightweight report summaries
func (s *DBStorage) ListReportSummaries(offset, limit int) ([]model.TestSummary, int64, error) {
var total int64
if err := s.db.Model(&Report{}).Count(&total).Error; err != nil {
return nil, 0, fmt.Errorf("failed to count reports: %w", err)
}
if total == 0 {
return []model.TestSummary{}, 0, nil
}
var selectExpr string
switch s.db.Dialector.Name() {
case "postgres":
selectExpr = `test_id, ` +
`(convert_from(report_json, 'UTF8')::jsonb->>'score')::int as score, ` +
`convert_from(report_json, 'UTF8')::jsonb->>'grade' as grade, ` +
`convert_from(report_json, 'UTF8')::jsonb->'dns_results'->>'from_domain' as from_domain, ` +
`created_at`
case "sqlite":
selectExpr = `test_id, ` +
`json_extract(report_json, '$.score') as score, ` +
`json_extract(report_json, '$.grade') as grade, ` +
`json_extract(report_json, '$.dns_results.from_domain') as from_domain, ` +
`created_at`
default:
return nil, 0, fmt.Errorf("history tests list not implemented in this database dialect")
}
var rows []reportSummaryRow
err := s.db.Model(&Report{}).
Select(selectExpr).
Order("created_at DESC").
Offset(offset).
Limit(limit).
Scan(&rows).Error
if err != nil {
return nil, 0, fmt.Errorf("failed to list report summaries: %w", err)
}
summaries := make([]model.TestSummary, 0, len(rows))
for _, r := range rows {
s := model.TestSummary{
TestId: utils.UUIDToBase32(r.TestID),
Score: r.Score,
Grade: model.TestSummaryGrade(r.Grade),
CreatedAt: r.CreatedAt,
}
if r.FromDomain != "" {
s.FromDomain = utils.PtrTo(r.FromDomain)
}
summaries = append(summaries, s)
}
return summaries, total, nil
}
// Close closes the database connection // Close closes the database connection
func (s *DBStorage) Close() error { func (s *DBStorage) Close() error {
sqlDB, err := s.db.DB() sqlDB, err := s.db.DB()

8
internal/api/helpers.go → internal/utils/ptr.go
View file

@ -1,5 +1,5 @@
// This file is part of the happyDeliver (R) project. // This file is part of the happyDeliver (R) project.
// Copyright (c) 2025 happyDomain // Copyright (c) 2026 happyDomain
// Authors: Pierre-Olivier Mercier, et al. // Authors: Pierre-Olivier Mercier, et al.
// //
// This program is offered under a commercial and under the AGPL license. // This program is offered under a commercial and under the AGPL license.
@ -19,11 +19,7 @@
// You should have received a copy of the GNU Affero General Public License // You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
package api package utils
func stringPtr(s string) *string {
return &s
}
// PtrTo returns a pointer to the provided value // PtrTo returns a pointer to the provided value
func PtrTo[T any](v T) *T { func PtrTo[T any](v T) *T {

14
pkg/analyzer/analyzer.go
View file

@ -28,7 +28,7 @@ import (
"github.com/google/uuid" "github.com/google/uuid"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/config" "git.happydns.org/happyDeliver/internal/config"
) )
@ -41,11 +41,13 @@ type EmailAnalyzer struct {
// NewEmailAnalyzer creates a new email analyzer with the given configuration // NewEmailAnalyzer creates a new email analyzer with the given configuration
func NewEmailAnalyzer(cfg *config.Config) *EmailAnalyzer { func NewEmailAnalyzer(cfg *config.Config) *EmailAnalyzer {
generator := NewReportGenerator( generator := NewReportGenerator(
cfg.Email.ReceiverHostname,
cfg.Analysis.DNSTimeout, cfg.Analysis.DNSTimeout,
cfg.Analysis.HTTPTimeout, cfg.Analysis.HTTPTimeout,
cfg.Analysis.RBLs, cfg.Analysis.RBLs,
cfg.Analysis.DNSWLs, cfg.Analysis.DNSWLs,
cfg.Analysis.CheckAllIPs, cfg.Analysis.CheckAllIPs,
cfg.Analysis.RspamdAPIURL,
) )
return &EmailAnalyzer{ return &EmailAnalyzer{
@ -57,7 +59,7 @@ func NewEmailAnalyzer(cfg *config.Config) *EmailAnalyzer {
type AnalysisResult struct { type AnalysisResult struct {
Email *EmailMessage Email *EmailMessage
Results *AnalysisResults Results *AnalysisResults
Report *api.Report Report *model.Report
} }
// AnalyzeEmailBytes performs complete email analysis from raw bytes // AnalyzeEmailBytes performs complete email analysis from raw bytes
@ -111,7 +113,7 @@ func (a *APIAdapter) AnalyzeEmailBytes(rawEmail []byte, testID uuid.UUID) ([]byt
} }
// AnalyzeDomain performs DNS analysis for a domain and returns the results // AnalyzeDomain performs DNS analysis for a domain and returns the results
func (a *APIAdapter) AnalyzeDomain(domain string) (*api.DNSResults, int, string) { func (a *APIAdapter) AnalyzeDomain(domain string) (*model.DNSResults, int, string) {
// Perform DNS analysis // Perform DNS analysis
dnsResults := a.analyzer.generator.dnsAnalyzer.AnalyzeDomainOnly(domain) dnsResults := a.analyzer.generator.dnsAnalyzer.AnalyzeDomainOnly(domain)
@ -122,7 +124,7 @@ func (a *APIAdapter) AnalyzeDomain(domain string) (*api.DNSResults, int, string)
} }
// CheckBlacklistIP checks a single IP address against DNS blacklists and whitelists // CheckBlacklistIP checks a single IP address against DNS blacklists and whitelists
func (a *APIAdapter) CheckBlacklistIP(ip string) ([]api.BlacklistCheck, []api.BlacklistCheck, int, int, string, error) { func (a *APIAdapter) CheckBlacklistIP(ip string) ([]model.BlacklistCheck, []model.BlacklistCheck, int, int, string, error) {
// Check the IP against all configured RBLs // Check the IP against all configured RBLs
checks, listedCount, err := a.analyzer.generator.rblChecker.CheckIP(ip) checks, listedCount, err := a.analyzer.generator.rblChecker.CheckIP(ip)
if err != nil { if err != nil {
@ -132,11 +134,11 @@ func (a *APIAdapter) CheckBlacklistIP(ip string) ([]api.BlacklistCheck, []api.Bl
// Calculate score using the existing function // Calculate score using the existing function
// Create a minimal RBLResults structure for scoring // Create a minimal RBLResults structure for scoring
results := &DNSListResults{ results := &DNSListResults{
Checks: map[string][]api.BlacklistCheck{ip: checks}, Checks: map[string][]model.BlacklistCheck{ip: checks},
IPsChecked: []string{ip}, IPsChecked: []string{ip},
ListedCount: listedCount, ListedCount: listedCount,
} }
score, grade := a.analyzer.generator.rblChecker.CalculateScore(results) score, grade := a.analyzer.generator.rblChecker.CalculateScore(results, false)
// Check the IP against all configured DNSWLs (informational only) // Check the IP against all configured DNSWLs (informational only)
whitelists, _, err := a.analyzer.generator.dnswlChecker.CheckIP(ip) whitelists, _, err := a.analyzer.generator.dnswlChecker.CheckIP(ip)

57
pkg/analyzer/authentication.go
View file

@ -24,23 +24,25 @@ package analyzer
import ( import (
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
// AuthenticationAnalyzer analyzes email authentication results // AuthenticationAnalyzer analyzes email authentication results
type AuthenticationAnalyzer struct{} type AuthenticationAnalyzer struct {
receiverHostname string
}
// NewAuthenticationAnalyzer creates a new authentication analyzer // NewAuthenticationAnalyzer creates a new authentication analyzer
func NewAuthenticationAnalyzer() *AuthenticationAnalyzer { func NewAuthenticationAnalyzer(receiverHostname string) *AuthenticationAnalyzer {
return &AuthenticationAnalyzer{} return &AuthenticationAnalyzer{receiverHostname: receiverHostname}
} }
// AnalyzeAuthentication extracts and analyzes authentication results from email headers // AnalyzeAuthentication extracts and analyzes authentication results from email headers
func (a *AuthenticationAnalyzer) AnalyzeAuthentication(email *EmailMessage) *api.AuthenticationResults { func (a *AuthenticationAnalyzer) AnalyzeAuthentication(email *EmailMessage) *model.AuthenticationResults {
results := &api.AuthenticationResults{} results := &model.AuthenticationResults{}
// Parse Authentication-Results headers // Parse Authentication-Results headers
authHeaders := email.GetAuthenticationResults() authHeaders := email.GetAuthenticationResults(a.receiverHostname)
for _, header := range authHeaders { for _, header := range authHeaders {
a.parseAuthenticationResultsHeader(header, results) a.parseAuthenticationResultsHeader(header, results)
} }
@ -63,7 +65,7 @@ func (a *AuthenticationAnalyzer) AnalyzeAuthentication(email *EmailMessage) *api
// parseAuthenticationResultsHeader parses an Authentication-Results header // parseAuthenticationResultsHeader parses an Authentication-Results header
// Format: example.com; spf=pass smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com // Format: example.com; spf=pass smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com
func (a *AuthenticationAnalyzer) parseAuthenticationResultsHeader(header string, results *api.AuthenticationResults) { func (a *AuthenticationAnalyzer) parseAuthenticationResultsHeader(header string, results *model.AuthenticationResults) {
// Split by semicolon to get individual results // Split by semicolon to get individual results
parts := strings.Split(header, ";") parts := strings.Split(header, ";")
if len(parts) < 2 { if len(parts) < 2 {
@ -89,7 +91,7 @@ func (a *AuthenticationAnalyzer) parseAuthenticationResultsHeader(header string,
dkimResult := a.parseDKIMResult(part) dkimResult := a.parseDKIMResult(part)
if dkimResult != nil { if dkimResult != nil {
if results.Dkim == nil { if results.Dkim == nil {
dkimList := []api.AuthResult{*dkimResult} dkimList := []model.AuthResult{*dkimResult}
results.Dkim = &dkimList results.Dkim = &dkimList
} else { } else {
*results.Dkim = append(*results.Dkim, *dkimResult) *results.Dkim = append(*results.Dkim, *dkimResult)
@ -143,34 +145,39 @@ func (a *AuthenticationAnalyzer) parseAuthenticationResultsHeader(header string,
// CalculateAuthenticationScore calculates the authentication score from auth results // CalculateAuthenticationScore calculates the authentication score from auth results
// Returns a score from 0-100 where higher is better // Returns a score from 0-100 where higher is better
func (a *AuthenticationAnalyzer) CalculateAuthenticationScore(results *api.AuthenticationResults) (int, string) { func (a *AuthenticationAnalyzer) CalculateAuthenticationScore(results *model.AuthenticationResults) (int, string) {
if results == nil { if results == nil {
return 0, "" return 0, ""
} }
score := 0 score := 0
// IPRev (15 points) // Core authentication (90 points total)
score += 15 * a.calculateIPRevScore(results) / 100 // SPF (30 points)
score += 30 * a.calculateSPFScore(results) / 100
// SPF (25 points) // DKIM (30 points)
score += 25 * a.calculateSPFScore(results) / 100 score += 30 * a.calculateDKIMScore(results) / 100
// DKIM (23 points) // DMARC (30 points)
score += 23 * a.calculateDKIMScore(results) / 100 score += 30 * a.calculateDMARCScore(results) / 100
// X-Google-DKIM (optional) - penalty if failed
score += 12 * a.calculateXGoogleDKIMScore(results) / 100
// X-Aligned-From
score += 2 * a.calculateXAlignedFromScore(results) / 100
// DMARC (25 points)
score += 25 * a.calculateDMARCScore(results) / 100
// BIMI (10 points) // BIMI (10 points)
score += 10 * a.calculateBIMIScore(results) / 100 score += 10 * a.calculateBIMIScore(results) / 100
// Penalty-only: IPRev (up to -7 points on failure)
if iprevScore := a.calculateIPRevScore(results); iprevScore < 100 {
score += 7 * (iprevScore - 100) / 100
}
// Penalty-only: X-Google-DKIM (up to -12 points on failure)
score += 12 * a.calculateXGoogleDKIMScore(results) / 100
// Penalty-only: X-Aligned-From (up to -5 points on failure)
if xAlignedScore := a.calculateXAlignedFromScore(results); xAlignedScore < 100 {
score += 5 * (xAlignedScore - 100) / 100
}
// Ensure score doesn't exceed 100 // Ensure score doesn't exceed 100
if score > 100 { if score > 100 {
score = 100 score = 100

25
pkg/analyzer/authentication_arc.go
View file

@ -27,7 +27,8 @@ import (
"slices" "slices"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// textprotoCanonical converts a header name to canonical form // textprotoCanonical converts a header name to canonical form
@ -52,24 +53,24 @@ func pluralize(count int) string {
// parseARCResult parses ARC result from Authentication-Results // parseARCResult parses ARC result from Authentication-Results
// Example: arc=pass // Example: arc=pass
func (a *AuthenticationAnalyzer) parseARCResult(part string) *api.ARCResult { func (a *AuthenticationAnalyzer) parseARCResult(part string) *model.ARCResult {
result := &api.ARCResult{} result := &model.ARCResult{}
// Extract result (pass, fail, none) // Extract result (pass, fail, none)
re := regexp.MustCompile(`arc=(\w+)`) re := regexp.MustCompile(`arc=(\w+)`)
if matches := re.FindStringSubmatch(part); len(matches) > 1 { if matches := re.FindStringSubmatch(part); len(matches) > 1 {
resultStr := strings.ToLower(matches[1]) resultStr := strings.ToLower(matches[1])
result.Result = api.ARCResultResult(resultStr) result.Result = model.ARCResultResult(resultStr)
} }
result.Details = api.PtrTo(strings.TrimPrefix(part, "arc=")) result.Details = utils.PtrTo(strings.TrimPrefix(part, "arc="))
return result return result
} }
// parseARCHeaders parses ARC headers from email message // parseARCHeaders parses ARC headers from email message
// ARC consists of three headers per hop: ARC-Authentication-Results, ARC-Message-Signature, ARC-Seal // ARC consists of three headers per hop: ARC-Authentication-Results, ARC-Message-Signature, ARC-Seal
func (a *AuthenticationAnalyzer) parseARCHeaders(email *EmailMessage) *api.ARCResult { func (a *AuthenticationAnalyzer) parseARCHeaders(email *EmailMessage) *model.ARCResult {
// Get all ARC-related headers // Get all ARC-related headers
arcAuthResults := email.Header[textprotoCanonical("ARC-Authentication-Results")] arcAuthResults := email.Header[textprotoCanonical("ARC-Authentication-Results")]
arcMessageSig := email.Header[textprotoCanonical("ARC-Message-Signature")] arcMessageSig := email.Header[textprotoCanonical("ARC-Message-Signature")]
@ -80,8 +81,8 @@ func (a *AuthenticationAnalyzer) parseARCHeaders(email *EmailMessage) *api.ARCRe
return nil return nil
} }
result := &api.ARCResult{ result := &model.ARCResult{
Result: api.ARCResultResultNone, Result: model.ARCResultResultNone,
} }
// Count the ARC chain length (number of sets) // Count the ARC chain length (number of sets)
@ -94,15 +95,15 @@ func (a *AuthenticationAnalyzer) parseARCHeaders(email *EmailMessage) *api.ARCRe
// Determine overall result // Determine overall result
if chainLength == 0 { if chainLength == 0 {
result.Result = api.ARCResultResultNone result.Result = model.ARCResultResultNone
details := "No ARC chain present" details := "No ARC chain present"
result.Details = &details result.Details = &details
} else if !chainValid { } else if !chainValid {
result.Result = api.ARCResultResultFail result.Result = model.ARCResultResultFail
details := fmt.Sprintf("ARC chain validation failed (chain length: %d)", chainLength) details := fmt.Sprintf("ARC chain validation failed (chain length: %d)", chainLength)
result.Details = &details result.Details = &details
} else { } else {
result.Result = api.ARCResultResultPass result.Result = model.ARCResultResultPass
details := fmt.Sprintf("ARC chain valid with %d intermediar%s", chainLength, pluralize(chainLength)) details := fmt.Sprintf("ARC chain valid with %d intermediar%s", chainLength, pluralize(chainLength))
result.Details = &details result.Details = &details
} }
@ -111,7 +112,7 @@ func (a *AuthenticationAnalyzer) parseARCHeaders(email *EmailMessage) *api.ARCRe
} }
// enhanceARCResult enhances an existing ARC result with chain information // enhanceARCResult enhances an existing ARC result with chain information
func (a *AuthenticationAnalyzer) enhanceARCResult(email *EmailMessage, arcResult *api.ARCResult) { func (a *AuthenticationAnalyzer) enhanceARCResult(email *EmailMessage, arcResult *model.ARCResult) {
if arcResult == nil { if arcResult == nil {
return return
} }

14
pkg/analyzer/authentication_arc_test.go
View file

@ -24,33 +24,33 @@ package analyzer
import ( import (
"testing" "testing"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
func TestParseARCResult(t *testing.T) { func TestParseARCResult(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
part string part string
expectedResult api.ARCResultResult expectedResult model.ARCResultResult
}{ }{
{ {
name: "ARC pass", name: "ARC pass",
part: "arc=pass", part: "arc=pass",
expectedResult: api.ARCResultResultPass, expectedResult: model.ARCResultResultPass,
}, },
{ {
name: "ARC fail", name: "ARC fail",
part: "arc=fail", part: "arc=fail",
expectedResult: api.ARCResultResultFail, expectedResult: model.ARCResultResultFail,
}, },
{ {
name: "ARC none", name: "ARC none",
part: "arc=none", part: "arc=none",
expectedResult: api.ARCResultResultNone, expectedResult: model.ARCResultResultNone,
}, },
} }
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
@ -136,7 +136,7 @@ func TestValidateARCChain(t *testing.T) {
}, },
} }
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {

17
pkg/analyzer/authentication_bimi.go
View file

@ -25,19 +25,20 @@ import (
"regexp" "regexp"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// parseBIMIResult parses BIMI result from Authentication-Results // parseBIMIResult parses BIMI result from Authentication-Results
// Example: bimi=pass header.d=example.com header.selector=default // Example: bimi=pass header.d=example.com header.selector=default
func (a *AuthenticationAnalyzer) parseBIMIResult(part string) *api.AuthResult { func (a *AuthenticationAnalyzer) parseBIMIResult(part string) *model.AuthResult {
result := &api.AuthResult{} result := &model.AuthResult{}
// Extract result (pass, fail, etc.) // Extract result (pass, fail, etc.)
re := regexp.MustCompile(`bimi=(\w+)`) re := regexp.MustCompile(`bimi=(\w+)`)
if matches := re.FindStringSubmatch(part); len(matches) > 1 { if matches := re.FindStringSubmatch(part); len(matches) > 1 {
resultStr := strings.ToLower(matches[1]) resultStr := strings.ToLower(matches[1])
result.Result = api.AuthResultResult(resultStr) result.Result = model.AuthResultResult(resultStr)
} }
// Extract domain (header.d or d) // Extract domain (header.d or d)
@ -54,17 +55,17 @@ func (a *AuthenticationAnalyzer) parseBIMIResult(part string) *api.AuthResult {
result.Selector = &selector result.Selector = &selector
} }
result.Details = api.PtrTo(strings.TrimPrefix(part, "bimi=")) result.Details = utils.PtrTo(strings.TrimPrefix(part, "bimi="))
return result return result
} }
func (a *AuthenticationAnalyzer) calculateBIMIScore(results *api.AuthenticationResults) (score int) { func (a *AuthenticationAnalyzer) calculateBIMIScore(results *model.AuthenticationResults) (score int) {
if results.Bimi != nil { if results.Bimi != nil {
switch results.Bimi.Result { switch results.Bimi.Result {
case api.AuthResultResultPass: case model.AuthResultResultPass:
return 100 return 100
case api.AuthResultResultDeclined: case model.AuthResultResultDeclined:
return 59 return 59
default: // fail default: // fail
return 0 return 0

14
pkg/analyzer/authentication_bimi_test.go
View file

@ -24,47 +24,47 @@ package analyzer
import ( import (
"testing" "testing"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
func TestParseBIMIResult(t *testing.T) { func TestParseBIMIResult(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
part string part string
expectedResult api.AuthResultResult expectedResult model.AuthResultResult
expectedDomain string expectedDomain string
expectedSelector string expectedSelector string
}{ }{
{ {
name: "BIMI pass with domain and selector", name: "BIMI pass with domain and selector",
part: "bimi=pass header.d=example.com header.selector=default", part: "bimi=pass header.d=example.com header.selector=default",
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
expectedDomain: "example.com", expectedDomain: "example.com",
expectedSelector: "default", expectedSelector: "default",
}, },
{ {
name: "BIMI fail", name: "BIMI fail",
part: "bimi=fail header.d=example.com header.selector=default", part: "bimi=fail header.d=example.com header.selector=default",
expectedResult: api.AuthResultResultFail, expectedResult: model.AuthResultResultFail,
expectedDomain: "example.com", expectedDomain: "example.com",
expectedSelector: "default", expectedSelector: "default",
}, },
{ {
name: "BIMI with short form (d= and selector=)", name: "BIMI with short form (d= and selector=)",
part: "bimi=pass d=example.com selector=v1", part: "bimi=pass d=example.com selector=v1",
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
expectedDomain: "example.com", expectedDomain: "example.com",
expectedSelector: "v1", expectedSelector: "v1",
}, },
{ {
name: "BIMI none", name: "BIMI none",
part: "bimi=none header.d=example.com", part: "bimi=none header.d=example.com",
expectedResult: api.AuthResultResultNone, expectedResult: model.AuthResultResultNone,
expectedDomain: "example.com", expectedDomain: "example.com",
}, },
} }
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {

15
pkg/analyzer/authentication_dkim.go
View file

@ -25,19 +25,20 @@ import (
"regexp" "regexp"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// parseDKIMResult parses DKIM result from Authentication-Results // parseDKIMResult parses DKIM result from Authentication-Results
// Example: dkim=pass header.d=example.com header.s=selector1 // Example: dkim=pass header.d=example.com header.s=selector1
func (a *AuthenticationAnalyzer) parseDKIMResult(part string) *api.AuthResult { func (a *AuthenticationAnalyzer) parseDKIMResult(part string) *model.AuthResult {
result := &api.AuthResult{} result := &model.AuthResult{}
// Extract result (pass, fail, etc.) // Extract result (pass, fail, etc.)
re := regexp.MustCompile(`dkim=(\w+)`) re := regexp.MustCompile(`dkim=(\w+)`)
if matches := re.FindStringSubmatch(part); len(matches) > 1 { if matches := re.FindStringSubmatch(part); len(matches) > 1 {
resultStr := strings.ToLower(matches[1]) resultStr := strings.ToLower(matches[1])
result.Result = api.AuthResultResult(resultStr) result.Result = model.AuthResultResult(resultStr)
} }
// Extract domain (header.d or d) // Extract domain (header.d or d)
@ -54,18 +55,18 @@ func (a *AuthenticationAnalyzer) parseDKIMResult(part string) *api.AuthResult {
result.Selector = &selector result.Selector = &selector
} }
result.Details = api.PtrTo(strings.TrimPrefix(part, "dkim=")) result.Details = utils.PtrTo(strings.TrimPrefix(part, "dkim="))
return result return result
} }
func (a *AuthenticationAnalyzer) calculateDKIMScore(results *api.AuthenticationResults) (score int) { func (a *AuthenticationAnalyzer) calculateDKIMScore(results *model.AuthenticationResults) (score int) {
// Expect at least one passing signature // Expect at least one passing signature
if results.Dkim != nil && len(*results.Dkim) > 0 { if results.Dkim != nil && len(*results.Dkim) > 0 {
hasPass := false hasPass := false
hasNonPass := false hasNonPass := false
for _, dkim := range *results.Dkim { for _, dkim := range *results.Dkim {
if dkim.Result == api.AuthResultResultPass { if dkim.Result == model.AuthResultResultPass {
hasPass = true hasPass = true
} else { } else {
hasNonPass = true hasNonPass = true

12
pkg/analyzer/authentication_dkim_test.go
View file

@ -24,41 +24,41 @@ package analyzer
import ( import (
"testing" "testing"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
func TestParseDKIMResult(t *testing.T) { func TestParseDKIMResult(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
part string part string
expectedResult api.AuthResultResult expectedResult model.AuthResultResult
expectedDomain string expectedDomain string
expectedSelector string expectedSelector string
}{ }{
{ {
name: "DKIM pass with domain and selector", name: "DKIM pass with domain and selector",
part: "dkim=pass header.d=example.com header.s=default", part: "dkim=pass header.d=example.com header.s=default",
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
expectedDomain: "example.com", expectedDomain: "example.com",
expectedSelector: "default", expectedSelector: "default",
}, },
{ {
name: "DKIM fail", name: "DKIM fail",
part: "dkim=fail header.d=example.com header.s=selector1", part: "dkim=fail header.d=example.com header.s=selector1",
expectedResult: api.AuthResultResultFail, expectedResult: model.AuthResultResultFail,
expectedDomain: "example.com", expectedDomain: "example.com",
expectedSelector: "selector1", expectedSelector: "selector1",
}, },
{ {
name: "DKIM with short form (d= and s=)", name: "DKIM with short form (d= and s=)",
part: "dkim=pass d=example.com s=default", part: "dkim=pass d=example.com s=default",
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
expectedDomain: "example.com", expectedDomain: "example.com",
expectedSelector: "default", expectedSelector: "default",
}, },
} }
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {

17
pkg/analyzer/authentication_dmarc.go
View file

@ -25,19 +25,20 @@ import (
"regexp" "regexp"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// parseDMARCResult parses DMARC result from Authentication-Results // parseDMARCResult parses DMARC result from Authentication-Results
// Example: dmarc=pass action=none header.from=example.com // Example: dmarc=pass action=none header.from=example.com
func (a *AuthenticationAnalyzer) parseDMARCResult(part string) *api.AuthResult { func (a *AuthenticationAnalyzer) parseDMARCResult(part string) *model.AuthResult {
result := &api.AuthResult{} result := &model.AuthResult{}
// Extract result (pass, fail, etc.) // Extract result (pass, fail, etc.)
re := regexp.MustCompile(`dmarc=(\w+)`) re := regexp.MustCompile(`dmarc=(\w+)`)
if matches := re.FindStringSubmatch(part); len(matches) > 1 { if matches := re.FindStringSubmatch(part); len(matches) > 1 {
resultStr := strings.ToLower(matches[1]) resultStr := strings.ToLower(matches[1])
result.Result = api.AuthResultResult(resultStr) result.Result = model.AuthResultResult(resultStr)
} }
// Extract domain (header.from) // Extract domain (header.from)
@ -47,17 +48,17 @@ func (a *AuthenticationAnalyzer) parseDMARCResult(part string) *api.AuthResult {
result.Domain = &domain result.Domain = &domain
} }
result.Details = api.PtrTo(strings.TrimPrefix(part, "dmarc=")) result.Details = utils.PtrTo(strings.TrimPrefix(part, "dmarc="))
return result return result
} }
func (a *AuthenticationAnalyzer) calculateDMARCScore(results *api.AuthenticationResults) (score int) { func (a *AuthenticationAnalyzer) calculateDMARCScore(results *model.AuthenticationResults) (score int) {
if results.Dmarc != nil { if results.Dmarc != nil {
switch results.Dmarc.Result { switch results.Dmarc.Result {
case api.AuthResultResultPass: case model.AuthResultResultPass:
return 100 return 100
case api.AuthResultResultNone: case model.AuthResultResultNone:
return 33 return 33
default: // fail default: // fail
return 0 return 0

10
pkg/analyzer/authentication_dmarc_test.go
View file

@ -24,31 +24,31 @@ package analyzer
import ( import (
"testing" "testing"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
func TestParseDMARCResult(t *testing.T) { func TestParseDMARCResult(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
part string part string
expectedResult api.AuthResultResult expectedResult model.AuthResultResult
expectedDomain string expectedDomain string
}{ }{
{ {
name: "DMARC pass", name: "DMARC pass",
part: "dmarc=pass action=none header.from=example.com", part: "dmarc=pass action=none header.from=example.com",
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
expectedDomain: "example.com", expectedDomain: "example.com",
}, },
{ {
name: "DMARC fail", name: "DMARC fail",
part: "dmarc=fail action=quarantine header.from=example.com", part: "dmarc=fail action=quarantine header.from=example.com",
expectedResult: api.AuthResultResultFail, expectedResult: model.AuthResultResultFail,
expectedDomain: "example.com", expectedDomain: "example.com",
}, },
} }
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {

17
pkg/analyzer/authentication_iprev.go
View file

@ -25,19 +25,20 @@ import (
"regexp" "regexp"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// parseIPRevResult parses IP reverse lookup result from Authentication-Results // parseIPRevResult parses IP reverse lookup result from Authentication-Results
// Example: iprev=pass smtp.remote-ip=195.110.101.58 (authsmtp74.register.it) // Example: iprev=pass smtp.remote-ip=195.110.101.58 (authsmtp74.register.it)
func (a *AuthenticationAnalyzer) parseIPRevResult(part string) *api.IPRevResult { func (a *AuthenticationAnalyzer) parseIPRevResult(part string) *model.IPRevResult {
result := &api.IPRevResult{} result := &model.IPRevResult{}
// Extract result (pass, fail, temperror, permerror, none) // Extract result (pass, fail, temperror, permerror, none)
re := regexp.MustCompile(`iprev=(\w+)`) re := regexp.MustCompile(`iprev=(\w+)`)
if matches := re.FindStringSubmatch(part); len(matches) > 1 { if matches := re.FindStringSubmatch(part); len(matches) > 1 {
resultStr := strings.ToLower(matches[1]) resultStr := strings.ToLower(matches[1])
result.Result = api.IPRevResultResult(resultStr) result.Result = model.IPRevResultResult(resultStr)
} }
// Extract IP address (smtp.remote-ip or remote-ip) // Extract IP address (smtp.remote-ip or remote-ip)
@ -54,20 +55,20 @@ func (a *AuthenticationAnalyzer) parseIPRevResult(part string) *api.IPRevResult
result.Hostname = &hostname result.Hostname = &hostname
} }
result.Details = api.PtrTo(strings.TrimPrefix(part, "iprev=")) result.Details = utils.PtrTo(strings.TrimPrefix(part, "iprev="))
return result return result
} }
func (a *AuthenticationAnalyzer) calculateIPRevScore(results *api.AuthenticationResults) (score int) { func (a *AuthenticationAnalyzer) calculateIPRevScore(results *model.AuthenticationResults) (score int) {
if results.Iprev != nil { if results.Iprev != nil {
switch results.Iprev.Result { switch results.Iprev.Result {
case api.Pass: case model.Pass:
return 100 return 100
default: // fail, temperror, permerror default: // fail, temperror, permerror
return 0 return 0
} }
} }
return 0 return 100
} }

77
pkg/analyzer/authentication_iprev_test.go
View file

@ -24,76 +24,77 @@ package analyzer
import ( import (
"testing" "testing"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
func TestParseIPRevResult(t *testing.T) { func TestParseIPRevResult(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
part string part string
expectedResult api.IPRevResultResult expectedResult model.IPRevResultResult
expectedIP *string expectedIP *string
expectedHostname *string expectedHostname *string
}{ }{
{ {
name: "IPRev pass with IP and hostname", name: "IPRev pass with IP and hostname",
part: "iprev=pass smtp.remote-ip=195.110.101.58 (authsmtp74.register.it)", part: "iprev=pass smtp.remote-ip=195.110.101.58 (authsmtp74.register.it)",
expectedResult: api.Pass, expectedResult: model.Pass,
expectedIP: api.PtrTo("195.110.101.58"), expectedIP: utils.PtrTo("195.110.101.58"),
expectedHostname: api.PtrTo("authsmtp74.register.it"), expectedHostname: utils.PtrTo("authsmtp74.register.it"),
}, },
{ {
name: "IPRev pass without smtp prefix", name: "IPRev pass without smtp prefix",
part: "iprev=pass remote-ip=192.0.2.1 (mail.example.com)", part: "iprev=pass remote-ip=192.0.2.1 (mail.example.com)",
expectedResult: api.Pass, expectedResult: model.Pass,
expectedIP: api.PtrTo("192.0.2.1"), expectedIP: utils.PtrTo("192.0.2.1"),
expectedHostname: api.PtrTo("mail.example.com"), expectedHostname: utils.PtrTo("mail.example.com"),
}, },
{ {
name: "IPRev fail", name: "IPRev fail",
part: "iprev=fail smtp.remote-ip=198.51.100.42 (unknown.host.com)", part: "iprev=fail smtp.remote-ip=198.51.100.42 (unknown.host.com)",
expectedResult: api.Fail, expectedResult: model.Fail,
expectedIP: api.PtrTo("198.51.100.42"), expectedIP: utils.PtrTo("198.51.100.42"),
expectedHostname: api.PtrTo("unknown.host.com"), expectedHostname: utils.PtrTo("unknown.host.com"),
}, },
{ {
name: "IPRev temperror", name: "IPRev temperror",
part: "iprev=temperror smtp.remote-ip=203.0.113.1", part: "iprev=temperror smtp.remote-ip=203.0.113.1",
expectedResult: api.Temperror, expectedResult: model.Temperror,
expectedIP: api.PtrTo("203.0.113.1"), expectedIP: utils.PtrTo("203.0.113.1"),
expectedHostname: nil, expectedHostname: nil,
}, },
{ {
name: "IPRev permerror", name: "IPRev permerror",
part: "iprev=permerror smtp.remote-ip=192.0.2.100", part: "iprev=permerror smtp.remote-ip=192.0.2.100",
expectedResult: api.Permerror, expectedResult: model.Permerror,
expectedIP: api.PtrTo("192.0.2.100"), expectedIP: utils.PtrTo("192.0.2.100"),
expectedHostname: nil, expectedHostname: nil,
}, },
{ {
name: "IPRev with IPv6", name: "IPRev with IPv6",
part: "iprev=pass smtp.remote-ip=2001:db8::1 (ipv6.example.com)", part: "iprev=pass smtp.remote-ip=2001:db8::1 (ipv6.example.com)",
expectedResult: api.Pass, expectedResult: model.Pass,
expectedIP: api.PtrTo("2001:db8::1"), expectedIP: utils.PtrTo("2001:db8::1"),
expectedHostname: api.PtrTo("ipv6.example.com"), expectedHostname: utils.PtrTo("ipv6.example.com"),
}, },
{ {
name: "IPRev with subdomain hostname", name: "IPRev with subdomain hostname",
part: "iprev=pass smtp.remote-ip=192.0.2.50 (mail.subdomain.example.com)", part: "iprev=pass smtp.remote-ip=192.0.2.50 (mail.subdomain.example.com)",
expectedResult: api.Pass, expectedResult: model.Pass,
expectedIP: api.PtrTo("192.0.2.50"), expectedIP: utils.PtrTo("192.0.2.50"),
expectedHostname: api.PtrTo("mail.subdomain.example.com"), expectedHostname: utils.PtrTo("mail.subdomain.example.com"),
}, },
{ {
name: "IPRev pass without parentheses", name: "IPRev pass without parentheses",
part: "iprev=pass smtp.remote-ip=192.0.2.200", part: "iprev=pass smtp.remote-ip=192.0.2.200",
expectedResult: api.Pass, expectedResult: model.Pass,
expectedIP: api.PtrTo("192.0.2.200"), expectedIP: utils.PtrTo("192.0.2.200"),
expectedHostname: nil, expectedHostname: nil,
}, },
} }
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
@ -142,29 +143,29 @@ func TestParseAuthenticationResultsHeader_IPRev(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
header string header string
expectedIPRevResult *api.IPRevResultResult expectedIPRevResult *model.IPRevResultResult
expectedIP *string expectedIP *string
expectedHostname *string expectedHostname *string
}{ }{
{ {
name: "IPRev pass in Authentication-Results", name: "IPRev pass in Authentication-Results",
header: "mx.google.com; iprev=pass smtp.remote-ip=195.110.101.58 (authsmtp74.register.it)", header: "mx.google.com; iprev=pass smtp.remote-ip=195.110.101.58 (authsmtp74.register.it)",
expectedIPRevResult: api.PtrTo(api.Pass), expectedIPRevResult: utils.PtrTo(model.Pass),
expectedIP: api.PtrTo("195.110.101.58"), expectedIP: utils.PtrTo("195.110.101.58"),
expectedHostname: api.PtrTo("authsmtp74.register.it"), expectedHostname: utils.PtrTo("authsmtp74.register.it"),
}, },
{ {
name: "IPRev with other authentication methods", name: "IPRev with other authentication methods",
header: "mx.google.com; spf=pass smtp.mailfrom=sender@example.com; iprev=pass smtp.remote-ip=192.0.2.1 (mail.example.com); dkim=pass header.d=example.com", header: "mx.google.com; spf=pass smtp.mailfrom=sender@example.com; iprev=pass smtp.remote-ip=192.0.2.1 (mail.example.com); dkim=pass header.d=example.com",
expectedIPRevResult: api.PtrTo(api.Pass), expectedIPRevResult: utils.PtrTo(model.Pass),
expectedIP: api.PtrTo("192.0.2.1"), expectedIP: utils.PtrTo("192.0.2.1"),
expectedHostname: api.PtrTo("mail.example.com"), expectedHostname: utils.PtrTo("mail.example.com"),
}, },
{ {
name: "IPRev fail", name: "IPRev fail",
header: "mx.google.com; iprev=fail smtp.remote-ip=198.51.100.42", header: "mx.google.com; iprev=fail smtp.remote-ip=198.51.100.42",
expectedIPRevResult: api.PtrTo(api.Fail), expectedIPRevResult: utils.PtrTo(model.Fail),
expectedIP: api.PtrTo("198.51.100.42"), expectedIP: utils.PtrTo("198.51.100.42"),
expectedHostname: nil, expectedHostname: nil,
}, },
{ {
@ -175,17 +176,17 @@ func TestParseAuthenticationResultsHeader_IPRev(t *testing.T) {
{ {
name: "Multiple IPRev results - only first is parsed", name: "Multiple IPRev results - only first is parsed",
header: "mx.google.com; iprev=pass smtp.remote-ip=192.0.2.1 (first.com); iprev=fail smtp.remote-ip=192.0.2.2 (second.com)", header: "mx.google.com; iprev=pass smtp.remote-ip=192.0.2.1 (first.com); iprev=fail smtp.remote-ip=192.0.2.2 (second.com)",
expectedIPRevResult: api.PtrTo(api.Pass), expectedIPRevResult: utils.PtrTo(model.Pass),
expectedIP: api.PtrTo("192.0.2.1"), expectedIP: utils.PtrTo("192.0.2.1"),
expectedHostname: api.PtrTo("first.com"), expectedHostname: utils.PtrTo("first.com"),
}, },
} }
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
results := &api.AuthenticationResults{} results := &model.AuthenticationResults{}
analyzer.parseAuthenticationResultsHeader(tt.header, results) analyzer.parseAuthenticationResultsHeader(tt.header, results)
// Check IPRev // Check IPRev

35
pkg/analyzer/authentication_spf.go
View file

@ -25,19 +25,20 @@ import (
"regexp" "regexp"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// parseSPFResult parses SPF result from Authentication-Results // parseSPFResult parses SPF result from Authentication-Results
// Example: spf=pass smtp.mailfrom=sender@example.com // Example: spf=pass smtp.mailfrom=sender@example.com
func (a *AuthenticationAnalyzer) parseSPFResult(part string) *api.AuthResult { func (a *AuthenticationAnalyzer) parseSPFResult(part string) *model.AuthResult {
result := &api.AuthResult{} result := &model.AuthResult{}
// Extract result (pass, fail, etc.) // Extract result (pass, fail, etc.)
re := regexp.MustCompile(`spf=(\w+)`) re := regexp.MustCompile(`spf=(\w+)`)
if matches := re.FindStringSubmatch(part); len(matches) > 1 { if matches := re.FindStringSubmatch(part); len(matches) > 1 {
resultStr := strings.ToLower(matches[1]) resultStr := strings.ToLower(matches[1])
result.Result = api.AuthResultResult(resultStr) result.Result = model.AuthResultResult(resultStr)
} }
// Extract domain // Extract domain
@ -51,25 +52,35 @@ func (a *AuthenticationAnalyzer) parseSPFResult(part string) *api.AuthResult {
} }
} }
result.Details = api.PtrTo(strings.TrimPrefix(part, "spf=")) result.Details = utils.PtrTo(strings.TrimPrefix(part, "spf="))
return result return result
} }
// parseLegacySPF attempts to parse SPF from Received-SPF header // parseLegacySPF attempts to parse SPF from Received-SPF header
func (a *AuthenticationAnalyzer) parseLegacySPF(email *EmailMessage) *api.AuthResult { func (a *AuthenticationAnalyzer) parseLegacySPF(email *EmailMessage) *model.AuthResult {
receivedSPF := email.Header.Get("Received-SPF") receivedSPF := email.Header.Get("Received-SPF")
if receivedSPF == "" { if receivedSPF == "" {
return nil return nil
} }
result := &api.AuthResult{} // Verify receiver matches our hostname
if a.receiverHostname != "" {
receiverRe := regexp.MustCompile(`receiver=([^\s;]+)`)
if matches := receiverRe.FindStringSubmatch(receivedSPF); len(matches) > 1 {
if matches[1] != a.receiverHostname {
return nil
}
}
}
result := &model.AuthResult{}
// Extract result (first word) // Extract result (first word)
parts := strings.Fields(receivedSPF) parts := strings.Fields(receivedSPF)
if len(parts) > 0 { if len(parts) > 0 {
resultStr := strings.ToLower(parts[0]) resultStr := strings.ToLower(parts[0])
result.Result = api.AuthResultResult(resultStr) result.Result = model.AuthResultResult(resultStr)
} }
result.Details = &receivedSPF result.Details = &receivedSPF
@ -87,14 +98,14 @@ func (a *AuthenticationAnalyzer) parseLegacySPF(email *EmailMessage) *api.AuthRe
return result return result
} }
func (a *AuthenticationAnalyzer) calculateSPFScore(results *api.AuthenticationResults) (score int) { func (a *AuthenticationAnalyzer) calculateSPFScore(results *model.AuthenticationResults) (score int) {
if results.Spf != nil { if results.Spf != nil {
switch results.Spf.Result { switch results.Spf.Result {
case api.AuthResultResultPass: case model.AuthResultResultPass:
return 100 return 100
case api.AuthResultResultNeutral, api.AuthResultResultNone: case model.AuthResultResultNeutral, model.AuthResultResultNone:
return 50 return 50
case api.AuthResultResultSoftfail: case model.AuthResultResultSoftfail:
return 17 return 17
default: // fail, temperror, permerror default: // fail, temperror, permerror
return 0 return 0

53
pkg/analyzer/authentication_spf_test.go
View file

@ -24,43 +24,44 @@ package analyzer
import ( import (
"testing" "testing"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
func TestParseSPFResult(t *testing.T) { func TestParseSPFResult(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
part string part string
expectedResult api.AuthResultResult expectedResult model.AuthResultResult
expectedDomain string expectedDomain string
}{ }{
{ {
name: "SPF pass with domain", name: "SPF pass with domain",
part: "spf=pass smtp.mailfrom=sender@example.com", part: "spf=pass smtp.mailfrom=sender@example.com",
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
expectedDomain: "example.com", expectedDomain: "example.com",
}, },
{ {
name: "SPF fail", name: "SPF fail",
part: "spf=fail smtp.mailfrom=sender@example.com", part: "spf=fail smtp.mailfrom=sender@example.com",
expectedResult: api.AuthResultResultFail, expectedResult: model.AuthResultResultFail,
expectedDomain: "example.com", expectedDomain: "example.com",
}, },
{ {
name: "SPF neutral", name: "SPF neutral",
part: "spf=neutral smtp.mailfrom=sender@example.com", part: "spf=neutral smtp.mailfrom=sender@example.com",
expectedResult: api.AuthResultResultNeutral, expectedResult: model.AuthResultResultNeutral,
expectedDomain: "example.com", expectedDomain: "example.com",
}, },
{ {
name: "SPF softfail", name: "SPF softfail",
part: "spf=softfail smtp.mailfrom=sender@example.com", part: "spf=softfail smtp.mailfrom=sender@example.com",
expectedResult: api.AuthResultResultSoftfail, expectedResult: model.AuthResultResultSoftfail,
expectedDomain: "example.com", expectedDomain: "example.com",
}, },
} }
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
@ -84,7 +85,7 @@ func TestParseLegacySPF(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
receivedSPF string receivedSPF string
expectedResult api.AuthResultResult expectedResult model.AuthResultResult
expectedDomain *string expectedDomain *string
expectNil bool expectNil bool
}{ }{
@ -97,8 +98,8 @@ func TestParseLegacySPF(t *testing.T) {
envelope-from="user@example.com"; envelope-from="user@example.com";
helo=smtp.example.com; helo=smtp.example.com;
client-ip=192.0.2.10`, client-ip=192.0.2.10`,
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
expectedDomain: api.PtrTo("example.com"), expectedDomain: utils.PtrTo("example.com"),
}, },
{ {
name: "SPF fail with sender", name: "SPF fail with sender",
@ -109,43 +110,43 @@ func TestParseLegacySPF(t *testing.T) {
sender="sender@test.com"; sender="sender@test.com";
helo=smtp.test.com; helo=smtp.test.com;
client-ip=192.0.2.20`, client-ip=192.0.2.20`,
expectedResult: api.AuthResultResultFail, expectedResult: model.AuthResultResultFail,
expectedDomain: api.PtrTo("test.com"), expectedDomain: utils.PtrTo("test.com"),
}, },
{ {
name: "SPF softfail", name: "SPF softfail",
receivedSPF: "softfail (example.com: transitioning domain of admin@example.org does not designate 192.0.2.30 as permitted sender) envelope-from=\"admin@example.org\"", receivedSPF: "softfail (example.com: transitioning domain of admin@example.org does not designate 192.0.2.30 as permitted sender) envelope-from=\"admin@example.org\"",
expectedResult: api.AuthResultResultSoftfail, expectedResult: model.AuthResultResultSoftfail,
expectedDomain: api.PtrTo("example.org"), expectedDomain: utils.PtrTo("example.org"),
}, },
{ {
name: "SPF neutral", name: "SPF neutral",
receivedSPF: "neutral (example.com: 192.0.2.40 is neither permitted nor denied by domain of info@domain.net) envelope-from=\"info@domain.net\"", receivedSPF: "neutral (example.com: 192.0.2.40 is neither permitted nor denied by domain of info@domain.net) envelope-from=\"info@domain.net\"",
expectedResult: api.AuthResultResultNeutral, expectedResult: model.AuthResultResultNeutral,
expectedDomain: api.PtrTo("domain.net"), expectedDomain: utils.PtrTo("domain.net"),
}, },
{ {
name: "SPF none", name: "SPF none",
receivedSPF: "none (example.com: domain of noreply@company.io has no SPF record) envelope-from=\"noreply@company.io\"", receivedSPF: "none (example.com: domain of noreply@company.io has no SPF record) envelope-from=\"noreply@company.io\"",
expectedResult: api.AuthResultResultNone, expectedResult: model.AuthResultResultNone,
expectedDomain: api.PtrTo("company.io"), expectedDomain: utils.PtrTo("company.io"),
}, },
{ {
name: "SPF temperror", name: "SPF temperror",
receivedSPF: "temperror (example.com: error in processing SPF record) envelope-from=\"support@shop.example\"", receivedSPF: "temperror (example.com: error in processing SPF record) envelope-from=\"support@shop.example\"",
expectedResult: api.AuthResultResultTemperror, expectedResult: model.AuthResultResultTemperror,
expectedDomain: api.PtrTo("shop.example"), expectedDomain: utils.PtrTo("shop.example"),
}, },
{ {
name: "SPF permerror", name: "SPF permerror",
receivedSPF: "permerror (example.com: domain of contact@invalid.test has invalid SPF record) envelope-from=\"contact@invalid.test\"", receivedSPF: "permerror (example.com: domain of contact@invalid.test has invalid SPF record) envelope-from=\"contact@invalid.test\"",
expectedResult: api.AuthResultResultPermerror, expectedResult: model.AuthResultResultPermerror,
expectedDomain: api.PtrTo("invalid.test"), expectedDomain: utils.PtrTo("invalid.test"),
}, },
{ {
name: "SPF pass without domain extraction", name: "SPF pass without domain extraction",
receivedSPF: "pass (example.com: 192.0.2.50 is authorized)", receivedSPF: "pass (example.com: 192.0.2.50 is authorized)",
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
expectedDomain: nil, expectedDomain: nil,
}, },
{ {
@ -156,12 +157,12 @@ func TestParseLegacySPF(t *testing.T) {
{ {
name: "SPF with unquoted envelope-from", name: "SPF with unquoted envelope-from",
receivedSPF: "pass (example.com: sender SPF authorized) envelope-from=postmaster@mail.example.net", receivedSPF: "pass (example.com: sender SPF authorized) envelope-from=postmaster@mail.example.net",
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
expectedDomain: api.PtrTo("mail.example.net"), expectedDomain: utils.PtrTo("mail.example.net"),
}, },
} }
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {

167
pkg/analyzer/authentication_test.go
View file

@ -24,83 +24,84 @@ package analyzer
import ( import (
"testing" "testing"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
func TestGetAuthenticationScore(t *testing.T) { func TestGetAuthenticationScore(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
results *api.AuthenticationResults results *model.AuthenticationResults
expectedScore int expectedScore int
}{ }{
{ {
name: "Perfect authentication (SPF + DKIM + DMARC)", name: "Perfect authentication (SPF + DKIM + DMARC)",
results: &api.AuthenticationResults{ results: &model.AuthenticationResults{
Spf: &api.AuthResult{ Spf: &model.AuthResult{
Result: api.AuthResultResultPass, Result: model.AuthResultResultPass,
}, },
Dkim: &[]api.AuthResult{ Dkim: &[]model.AuthResult{
{Result: api.AuthResultResultPass}, {Result: model.AuthResultResultPass},
}, },
Dmarc: &api.AuthResult{ Dmarc: &model.AuthResult{
Result: api.AuthResultResultPass, Result: model.AuthResultResultPass,
}, },
}, },
expectedScore: 73, // SPF=25 + DKIM=23 + DMARC=25 expectedScore: 73, // SPF=25 + DKIM=23 + DMARC=25
}, },
{ {
name: "SPF and DKIM only", name: "SPF and DKIM only",
results: &api.AuthenticationResults{ results: &model.AuthenticationResults{
Spf: &api.AuthResult{ Spf: &model.AuthResult{
Result: api.AuthResultResultPass, Result: model.AuthResultResultPass,
}, },
Dkim: &[]api.AuthResult{ Dkim: &[]model.AuthResult{
{Result: api.AuthResultResultPass}, {Result: model.AuthResultResultPass},
}, },
}, },
expectedScore: 48, // SPF=25 + DKIM=23 expectedScore: 48, // SPF=25 + DKIM=23
}, },
{ {
name: "SPF fail, DKIM pass", name: "SPF fail, DKIM pass",
results: &api.AuthenticationResults{ results: &model.AuthenticationResults{
Spf: &api.AuthResult{ Spf: &model.AuthResult{
Result: api.AuthResultResultFail, Result: model.AuthResultResultFail,
}, },
Dkim: &[]api.AuthResult{ Dkim: &[]model.AuthResult{
{Result: api.AuthResultResultPass}, {Result: model.AuthResultResultPass},
}, },
}, },
expectedScore: 23, // SPF=0 + DKIM=23 expectedScore: 23, // SPF=0 + DKIM=23
}, },
{ {
name: "SPF softfail", name: "SPF softfail",
results: &api.AuthenticationResults{ results: &model.AuthenticationResults{
Spf: &api.AuthResult{ Spf: &model.AuthResult{
Result: api.AuthResultResultSoftfail, Result: model.AuthResultResultSoftfail,
}, },
}, },
expectedScore: 4, expectedScore: 4,
}, },
{ {
name: "No authentication", name: "No authentication",
results: &api.AuthenticationResults{}, results: &model.AuthenticationResults{},
expectedScore: 0, expectedScore: 0,
}, },
{ {
name: "BIMI adds to score", name: "BIMI adds to score",
results: &api.AuthenticationResults{ results: &model.AuthenticationResults{
Spf: &api.AuthResult{ Spf: &model.AuthResult{
Result: api.AuthResultResultPass, Result: model.AuthResultResultPass,
}, },
Bimi: &api.AuthResult{ Bimi: &model.AuthResult{
Result: api.AuthResultResultPass, Result: model.AuthResultResultPass,
}, },
}, },
expectedScore: 35, // SPF (25) + BIMI (10) expectedScore: 35, // SPF (25) + BIMI (10)
}, },
} }
scorer := NewAuthenticationAnalyzer() scorer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
@ -117,30 +118,30 @@ func TestParseAuthenticationResultsHeader(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
header string header string
expectedSPFResult *api.AuthResultResult expectedSPFResult *model.AuthResultResult
expectedSPFDomain *string expectedSPFDomain *string
expectedDKIMCount int expectedDKIMCount int
expectedDKIMResult *api.AuthResultResult expectedDKIMResult *model.AuthResultResult
expectedDMARCResult *api.AuthResultResult expectedDMARCResult *model.AuthResultResult
expectedDMARCDomain *string expectedDMARCDomain *string
expectedBIMIResult *api.AuthResultResult expectedBIMIResult *model.AuthResultResult
expectedARCResult *api.ARCResultResult expectedARCResult *model.ARCResultResult
}{ }{
{ {
name: "Complete authentication results", name: "Complete authentication results",
header: "mx.google.com; spf=pass smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com header.s=default; dmarc=pass action=none header.from=example.com", header: "mx.google.com; spf=pass smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com header.s=default; dmarc=pass action=none header.from=example.com",
expectedSPFResult: api.PtrTo(api.AuthResultResultPass), expectedSPFResult: utils.PtrTo(model.AuthResultResultPass),
expectedSPFDomain: api.PtrTo("example.com"), expectedSPFDomain: utils.PtrTo("example.com"),
expectedDKIMCount: 1, expectedDKIMCount: 1,
expectedDKIMResult: api.PtrTo(api.AuthResultResultPass), expectedDKIMResult: utils.PtrTo(model.AuthResultResultPass),
expectedDMARCResult: api.PtrTo(api.AuthResultResultPass), expectedDMARCResult: utils.PtrTo(model.AuthResultResultPass),
expectedDMARCDomain: api.PtrTo("example.com"), expectedDMARCDomain: utils.PtrTo("example.com"),
}, },
{ {
name: "SPF only", name: "SPF only",
header: "mail.example.com; spf=pass smtp.mailfrom=user@domain.com", header: "mail.example.com; spf=pass smtp.mailfrom=user@domain.com",
expectedSPFResult: api.PtrTo(api.AuthResultResultPass), expectedSPFResult: utils.PtrTo(model.AuthResultResultPass),
expectedSPFDomain: api.PtrTo("domain.com"), expectedSPFDomain: utils.PtrTo("domain.com"),
expectedDKIMCount: 0, expectedDKIMCount: 0,
expectedDMARCResult: nil, expectedDMARCResult: nil,
}, },
@ -149,68 +150,68 @@ func TestParseAuthenticationResultsHeader(t *testing.T) {
header: "mail.example.com; dkim=pass header.d=example.com header.s=selector1", header: "mail.example.com; dkim=pass header.d=example.com header.s=selector1",
expectedSPFResult: nil, expectedSPFResult: nil,
expectedDKIMCount: 1, expectedDKIMCount: 1,
expectedDKIMResult: api.PtrTo(api.AuthResultResultPass), expectedDKIMResult: utils.PtrTo(model.AuthResultResultPass),
}, },
{ {
name: "Multiple DKIM signatures", name: "Multiple DKIM signatures",
header: "mail.example.com; dkim=pass header.d=example.com header.s=s1; dkim=pass header.d=example.com header.s=s2", header: "mail.example.com; dkim=pass header.d=example.com header.s=s1; dkim=pass header.d=example.com header.s=s2",
expectedSPFResult: nil, expectedSPFResult: nil,
expectedDKIMCount: 2, expectedDKIMCount: 2,
expectedDKIMResult: api.PtrTo(api.AuthResultResultPass), expectedDKIMResult: utils.PtrTo(model.AuthResultResultPass),
expectedDMARCResult: nil, expectedDMARCResult: nil,
}, },
{ {
name: "SPF fail with DKIM pass", name: "SPF fail with DKIM pass",
header: "mail.example.com; spf=fail smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com header.s=default", header: "mail.example.com; spf=fail smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com header.s=default",
expectedSPFResult: api.PtrTo(api.AuthResultResultFail), expectedSPFResult: utils.PtrTo(model.AuthResultResultFail),
expectedSPFDomain: api.PtrTo("example.com"), expectedSPFDomain: utils.PtrTo("example.com"),
expectedDKIMCount: 1, expectedDKIMCount: 1,
expectedDKIMResult: api.PtrTo(api.AuthResultResultPass), expectedDKIMResult: utils.PtrTo(model.AuthResultResultPass),
expectedDMARCResult: nil, expectedDMARCResult: nil,
}, },
{ {
name: "SPF softfail", name: "SPF softfail",
header: "mail.example.com; spf=softfail smtp.mailfrom=sender@example.com", header: "mail.example.com; spf=softfail smtp.mailfrom=sender@example.com",
expectedSPFResult: api.PtrTo(api.AuthResultResultSoftfail), expectedSPFResult: utils.PtrTo(model.AuthResultResultSoftfail),
expectedSPFDomain: api.PtrTo("example.com"), expectedSPFDomain: utils.PtrTo("example.com"),
expectedDKIMCount: 0, expectedDKIMCount: 0,
expectedDMARCResult: nil, expectedDMARCResult: nil,
}, },
{ {
name: "DMARC fail", name: "DMARC fail",
header: "mail.example.com; spf=pass smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com header.s=default; dmarc=fail action=quarantine header.from=example.com", header: "mail.example.com; spf=pass smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com header.s=default; dmarc=fail action=quarantine header.from=example.com",
expectedSPFResult: api.PtrTo(api.AuthResultResultPass), expectedSPFResult: utils.PtrTo(model.AuthResultResultPass),
expectedDKIMCount: 1, expectedDKIMCount: 1,
expectedDKIMResult: api.PtrTo(api.AuthResultResultPass), expectedDKIMResult: utils.PtrTo(model.AuthResultResultPass),
expectedDMARCResult: api.PtrTo(api.AuthResultResultFail), expectedDMARCResult: utils.PtrTo(model.AuthResultResultFail),
expectedDMARCDomain: api.PtrTo("example.com"), expectedDMARCDomain: utils.PtrTo("example.com"),
}, },
{ {
name: "BIMI pass", name: "BIMI pass",
header: "mail.example.com; spf=pass smtp.mailfrom=sender@example.com; bimi=pass header.d=example.com header.selector=default", header: "mail.example.com; spf=pass smtp.mailfrom=sender@example.com; bimi=pass header.d=example.com header.selector=default",
expectedSPFResult: api.PtrTo(api.AuthResultResultPass), expectedSPFResult: utils.PtrTo(model.AuthResultResultPass),
expectedSPFDomain: api.PtrTo("example.com"), expectedSPFDomain: utils.PtrTo("example.com"),
expectedDKIMCount: 0, expectedDKIMCount: 0,
expectedBIMIResult: api.PtrTo(api.AuthResultResultPass), expectedBIMIResult: utils.PtrTo(model.AuthResultResultPass),
}, },
{ {
name: "ARC pass", name: "ARC pass",
header: "mail.example.com; arc=pass", header: "mail.example.com; arc=pass",
expectedSPFResult: nil, expectedSPFResult: nil,
expectedDKIMCount: 0, expectedDKIMCount: 0,
expectedARCResult: api.PtrTo(api.ARCResultResultPass), expectedARCResult: utils.PtrTo(model.ARCResultResultPass),
}, },
{ {
name: "All authentication methods", name: "All authentication methods",
header: "mx.google.com; spf=pass smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com header.s=default; dmarc=pass action=none header.from=example.com; bimi=pass header.d=example.com header.selector=v1; arc=pass", header: "mx.google.com; spf=pass smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com header.s=default; dmarc=pass action=none header.from=example.com; bimi=pass header.d=example.com header.selector=v1; arc=pass",
expectedSPFResult: api.PtrTo(api.AuthResultResultPass), expectedSPFResult: utils.PtrTo(model.AuthResultResultPass),
expectedSPFDomain: api.PtrTo("example.com"), expectedSPFDomain: utils.PtrTo("example.com"),
expectedDKIMCount: 1, expectedDKIMCount: 1,
expectedDKIMResult: api.PtrTo(api.AuthResultResultPass), expectedDKIMResult: utils.PtrTo(model.AuthResultResultPass),
expectedDMARCResult: api.PtrTo(api.AuthResultResultPass), expectedDMARCResult: utils.PtrTo(model.AuthResultResultPass),
expectedDMARCDomain: api.PtrTo("example.com"), expectedDMARCDomain: utils.PtrTo("example.com"),
expectedBIMIResult: api.PtrTo(api.AuthResultResultPass), expectedBIMIResult: utils.PtrTo(model.AuthResultResultPass),
expectedARCResult: api.PtrTo(api.ARCResultResultPass), expectedARCResult: utils.PtrTo(model.ARCResultResultPass),
}, },
{ {
name: "Empty header (authserv-id only)", name: "Empty header (authserv-id only)",
@ -221,8 +222,8 @@ func TestParseAuthenticationResultsHeader(t *testing.T) {
{ {
name: "Empty parts with semicolons", name: "Empty parts with semicolons",
header: "mx.google.com; ; ; spf=pass smtp.mailfrom=sender@example.com; ;", header: "mx.google.com; ; ; spf=pass smtp.mailfrom=sender@example.com; ;",
expectedSPFResult: api.PtrTo(api.AuthResultResultPass), expectedSPFResult: utils.PtrTo(model.AuthResultResultPass),
expectedSPFDomain: api.PtrTo("example.com"), expectedSPFDomain: utils.PtrTo("example.com"),
expectedDKIMCount: 0, expectedDKIMCount: 0,
}, },
{ {
@ -230,28 +231,28 @@ func TestParseAuthenticationResultsHeader(t *testing.T) {
header: "mail.example.com; dkim=pass d=example.com s=selector1", header: "mail.example.com; dkim=pass d=example.com s=selector1",
expectedSPFResult: nil, expectedSPFResult: nil,
expectedDKIMCount: 1, expectedDKIMCount: 1,
expectedDKIMResult: api.PtrTo(api.AuthResultResultPass), expectedDKIMResult: utils.PtrTo(model.AuthResultResultPass),
}, },
{ {
name: "SPF neutral", name: "SPF neutral",
header: "mail.example.com; spf=neutral smtp.mailfrom=sender@example.com", header: "mail.example.com; spf=neutral smtp.mailfrom=sender@example.com",
expectedSPFResult: api.PtrTo(api.AuthResultResultNeutral), expectedSPFResult: utils.PtrTo(model.AuthResultResultNeutral),
expectedSPFDomain: api.PtrTo("example.com"), expectedSPFDomain: utils.PtrTo("example.com"),
expectedDKIMCount: 0, expectedDKIMCount: 0,
}, },
{ {
name: "SPF none", name: "SPF none",
header: "mail.example.com; spf=none", header: "mail.example.com; spf=none",
expectedSPFResult: api.PtrTo(api.AuthResultResultNone), expectedSPFResult: utils.PtrTo(model.AuthResultResultNone),
expectedDKIMCount: 0, expectedDKIMCount: 0,
}, },
} }
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
results := &api.AuthenticationResults{} results := &model.AuthenticationResults{}
analyzer.parseAuthenticationResultsHeader(tt.header, results) analyzer.parseAuthenticationResultsHeader(tt.header, results)
// Check SPF // Check SPF
@ -353,17 +354,17 @@ func TestParseAuthenticationResultsHeader(t *testing.T) {
func TestParseAuthenticationResultsHeader_OnlyFirstResultParsed(t *testing.T) { func TestParseAuthenticationResultsHeader_OnlyFirstResultParsed(t *testing.T) {
// This test verifies that only the first occurrence of each auth method is parsed // This test verifies that only the first occurrence of each auth method is parsed
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
t.Run("Multiple SPF results - only first is parsed", func(t *testing.T) { t.Run("Multiple SPF results - only first is parsed", func(t *testing.T) {
header := "mail.example.com; spf=pass smtp.mailfrom=first@example.com; spf=fail smtp.mailfrom=second@example.com" header := "mail.example.com; spf=pass smtp.mailfrom=first@example.com; spf=fail smtp.mailfrom=second@example.com"
results := &api.AuthenticationResults{} results := &model.AuthenticationResults{}
analyzer.parseAuthenticationResultsHeader(header, results) analyzer.parseAuthenticationResultsHeader(header, results)
if results.Spf == nil { if results.Spf == nil {
t.Fatal("Expected SPF result, got nil") t.Fatal("Expected SPF result, got nil")
} }
if results.Spf.Result != api.AuthResultResultPass { if results.Spf.Result != model.AuthResultResultPass {
t.Errorf("Expected first SPF result (pass), got %v", results.Spf.Result) t.Errorf("Expected first SPF result (pass), got %v", results.Spf.Result)
} }
if results.Spf.Domain == nil || *results.Spf.Domain != "example.com" { if results.Spf.Domain == nil || *results.Spf.Domain != "example.com" {
@ -373,13 +374,13 @@ func TestParseAuthenticationResultsHeader_OnlyFirstResultParsed(t *testing.T) {
t.Run("Multiple DMARC results - only first is parsed", func(t *testing.T) { t.Run("Multiple DMARC results - only first is parsed", func(t *testing.T) {
header := "mail.example.com; dmarc=pass header.from=first.com; dmarc=fail header.from=second.com" header := "mail.example.com; dmarc=pass header.from=first.com; dmarc=fail header.from=second.com"
results := &api.AuthenticationResults{} results := &model.AuthenticationResults{}
analyzer.parseAuthenticationResultsHeader(header, results) analyzer.parseAuthenticationResultsHeader(header, results)
if results.Dmarc == nil { if results.Dmarc == nil {
t.Fatal("Expected DMARC result, got nil") t.Fatal("Expected DMARC result, got nil")
} }
if results.Dmarc.Result != api.AuthResultResultPass { if results.Dmarc.Result != model.AuthResultResultPass {
t.Errorf("Expected first DMARC result (pass), got %v", results.Dmarc.Result) t.Errorf("Expected first DMARC result (pass), got %v", results.Dmarc.Result)
} }
if results.Dmarc.Domain == nil || *results.Dmarc.Domain != "first.com" { if results.Dmarc.Domain == nil || *results.Dmarc.Domain != "first.com" {
@ -389,26 +390,26 @@ func TestParseAuthenticationResultsHeader_OnlyFirstResultParsed(t *testing.T) {
t.Run("Multiple ARC results - only first is parsed", func(t *testing.T) { t.Run("Multiple ARC results - only first is parsed", func(t *testing.T) {
header := "mail.example.com; arc=pass; arc=fail" header := "mail.example.com; arc=pass; arc=fail"
results := &api.AuthenticationResults{} results := &model.AuthenticationResults{}
analyzer.parseAuthenticationResultsHeader(header, results) analyzer.parseAuthenticationResultsHeader(header, results)
if results.Arc == nil { if results.Arc == nil {
t.Fatal("Expected ARC result, got nil") t.Fatal("Expected ARC result, got nil")
} }
if results.Arc.Result != api.ARCResultResultPass { if results.Arc.Result != model.ARCResultResultPass {
t.Errorf("Expected first ARC result (pass), got %v", results.Arc.Result) t.Errorf("Expected first ARC result (pass), got %v", results.Arc.Result)
} }
}) })
t.Run("Multiple BIMI results - only first is parsed", func(t *testing.T) { t.Run("Multiple BIMI results - only first is parsed", func(t *testing.T) {
header := "mail.example.com; bimi=pass header.d=first.com; bimi=fail header.d=second.com" header := "mail.example.com; bimi=pass header.d=first.com; bimi=fail header.d=second.com"
results := &api.AuthenticationResults{} results := &model.AuthenticationResults{}
analyzer.parseAuthenticationResultsHeader(header, results) analyzer.parseAuthenticationResultsHeader(header, results)
if results.Bimi == nil { if results.Bimi == nil {
t.Fatal("Expected BIMI result, got nil") t.Fatal("Expected BIMI result, got nil")
} }
if results.Bimi.Result != api.AuthResultResultPass { if results.Bimi.Result != model.AuthResultResultPass {
t.Errorf("Expected first BIMI result (pass), got %v", results.Bimi.Result) t.Errorf("Expected first BIMI result (pass), got %v", results.Bimi.Result)
} }
if results.Bimi.Domain == nil || *results.Bimi.Domain != "first.com" { if results.Bimi.Domain == nil || *results.Bimi.Domain != "first.com" {
@ -419,7 +420,7 @@ func TestParseAuthenticationResultsHeader_OnlyFirstResultParsed(t *testing.T) {
t.Run("Multiple DKIM results - all are parsed", func(t *testing.T) { t.Run("Multiple DKIM results - all are parsed", func(t *testing.T) {
// DKIM is special - multiple signatures should all be collected // DKIM is special - multiple signatures should all be collected
header := "mail.example.com; dkim=pass header.d=first.com header.s=s1; dkim=fail header.d=second.com header.s=s2" header := "mail.example.com; dkim=pass header.d=first.com header.s=s1; dkim=fail header.d=second.com header.s=s2"
results := &api.AuthenticationResults{} results := &model.AuthenticationResults{}
analyzer.parseAuthenticationResultsHeader(header, results) analyzer.parseAuthenticationResultsHeader(header, results)
if results.Dkim == nil { if results.Dkim == nil {
@ -428,10 +429,10 @@ func TestParseAuthenticationResultsHeader_OnlyFirstResultParsed(t *testing.T) {
if len(*results.Dkim) != 2 { if len(*results.Dkim) != 2 {
t.Errorf("Expected 2 DKIM results, got %d", len(*results.Dkim)) t.Errorf("Expected 2 DKIM results, got %d", len(*results.Dkim))
} }
if (*results.Dkim)[0].Result != api.AuthResultResultPass { if (*results.Dkim)[0].Result != model.AuthResultResultPass {
t.Errorf("Expected first DKIM result to be pass, got %v", (*results.Dkim)[0].Result) t.Errorf("Expected first DKIM result to be pass, got %v", (*results.Dkim)[0].Result)
} }
if (*results.Dkim)[1].Result != api.AuthResultResultFail { if (*results.Dkim)[1].Result != model.AuthResultResultFail {
t.Errorf("Expected second DKIM result to be fail, got %v", (*results.Dkim)[1].Result) t.Errorf("Expected second DKIM result to be fail, got %v", (*results.Dkim)[1].Result)
} }
}) })

19
pkg/analyzer/authentication_x_aligned_from.go
View file

@ -25,34 +25,35 @@ import (
"regexp" "regexp"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// parseXAlignedFromResult parses X-Aligned-From result from Authentication-Results // parseXAlignedFromResult parses X-Aligned-From result from Authentication-Results
// Example: x-aligned-from=pass (Address match) // Example: x-aligned-from=pass (Address match)
func (a *AuthenticationAnalyzer) parseXAlignedFromResult(part string) *api.AuthResult { func (a *AuthenticationAnalyzer) parseXAlignedFromResult(part string) *model.AuthResult {
result := &api.AuthResult{} result := &model.AuthResult{}
// Extract result (pass, fail, etc.) // Extract result (pass, fail, etc.)
re := regexp.MustCompile(`x-aligned-from=([\w]+)`) re := regexp.MustCompile(`x-aligned-from=([\w]+)`)
if matches := re.FindStringSubmatch(part); len(matches) > 1 { if matches := re.FindStringSubmatch(part); len(matches) > 1 {
resultStr := strings.ToLower(matches[1]) resultStr := strings.ToLower(matches[1])
result.Result = api.AuthResultResult(resultStr) result.Result = model.AuthResultResult(resultStr)
} }
// Extract details (everything after the result) // Extract details (everything after the result)
result.Details = api.PtrTo(strings.TrimPrefix(part, "x-aligned-from=")) result.Details = utils.PtrTo(strings.TrimPrefix(part, "x-aligned-from="))
return result return result
} }
func (a *AuthenticationAnalyzer) calculateXAlignedFromScore(results *api.AuthenticationResults) (score int) { func (a *AuthenticationAnalyzer) calculateXAlignedFromScore(results *model.AuthenticationResults) (score int) {
if results.XAlignedFrom != nil { if results.XAlignedFrom != nil {
switch results.XAlignedFrom.Result { switch results.XAlignedFrom.Result {
case api.AuthResultResultPass: case model.AuthResultResultPass:
// pass: positive contribution // pass: positive contribution
return 100 return 100
case api.AuthResultResultFail: case model.AuthResultResultFail:
// fail: negative contribution // fail: negative contribution
return 0 return 0
default: default:
@ -61,5 +62,5 @@ func (a *AuthenticationAnalyzer) calculateXAlignedFromScore(results *api.Authent
} }
} }
return 0 return 100
} }

38
pkg/analyzer/authentication_x_aligned_from_test.go
View file

@ -24,49 +24,49 @@ package analyzer
import ( import (
"testing" "testing"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
func TestParseXAlignedFromResult(t *testing.T) { func TestParseXAlignedFromResult(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
part string part string
expectedResult api.AuthResultResult expectedResult model.AuthResultResult
expectedDetail string expectedDetail string
}{ }{
{ {
name: "x-aligned-from pass with details", name: "x-aligned-from pass with details",
part: "x-aligned-from=pass (Address match)", part: "x-aligned-from=pass (Address match)",
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
expectedDetail: "pass (Address match)", expectedDetail: "pass (Address match)",
}, },
{ {
name: "x-aligned-from fail with reason", name: "x-aligned-from fail with reason",
part: "x-aligned-from=fail (Address mismatch)", part: "x-aligned-from=fail (Address mismatch)",
expectedResult: api.AuthResultResultFail, expectedResult: model.AuthResultResultFail,
expectedDetail: "fail (Address mismatch)", expectedDetail: "fail (Address mismatch)",
}, },
{ {
name: "x-aligned-from pass minimal", name: "x-aligned-from pass minimal",
part: "x-aligned-from=pass", part: "x-aligned-from=pass",
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
expectedDetail: "pass", expectedDetail: "pass",
}, },
{ {
name: "x-aligned-from neutral", name: "x-aligned-from neutral",
part: "x-aligned-from=neutral (No alignment check performed)", part: "x-aligned-from=neutral (No alignment check performed)",
expectedResult: api.AuthResultResultNeutral, expectedResult: model.AuthResultResultNeutral,
expectedDetail: "neutral (No alignment check performed)", expectedDetail: "neutral (No alignment check performed)",
}, },
{ {
name: "x-aligned-from none", name: "x-aligned-from none",
part: "x-aligned-from=none", part: "x-aligned-from=none",
expectedResult: api.AuthResultResultNone, expectedResult: model.AuthResultResultNone,
expectedDetail: "none", expectedDetail: "none",
}, },
} }
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
@ -88,34 +88,34 @@ func TestParseXAlignedFromResult(t *testing.T) {
func TestCalculateXAlignedFromScore(t *testing.T) { func TestCalculateXAlignedFromScore(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
result *api.AuthResult result *model.AuthResult
expectedScore int expectedScore int
}{ }{
{ {
name: "pass result gives positive score", name: "pass result gives positive score",
result: &api.AuthResult{ result: &model.AuthResult{
Result: api.AuthResultResultPass, Result: model.AuthResultResultPass,
}, },
expectedScore: 100, expectedScore: 100,
}, },
{ {
name: "fail result gives zero score", name: "fail result gives zero score",
result: &api.AuthResult{ result: &model.AuthResult{
Result: api.AuthResultResultFail, Result: model.AuthResultResultFail,
}, },
expectedScore: 0, expectedScore: 0,
}, },
{ {
name: "neutral result gives zero score", name: "neutral result gives zero score",
result: &api.AuthResult{ result: &model.AuthResult{
Result: api.AuthResultResultNeutral, Result: model.AuthResultResultNeutral,
}, },
expectedScore: 0, expectedScore: 0,
}, },
{ {
name: "none result gives zero score", name: "none result gives zero score",
result: &api.AuthResult{ result: &model.AuthResult{
Result: api.AuthResultResultNone, Result: model.AuthResultResultNone,
}, },
expectedScore: 0, expectedScore: 0,
}, },
@ -126,11 +126,11 @@ func TestCalculateXAlignedFromScore(t *testing.T) {
}, },
} }
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
results := &api.AuthenticationResults{ results := &model.AuthenticationResults{
XAlignedFrom: tt.result, XAlignedFrom: tt.result,
} }

15
pkg/analyzer/authentication_x_google_dkim.go
View file

@ -25,19 +25,20 @@ import (
"regexp" "regexp"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// parseXGoogleDKIMResult parses Google DKIM result from Authentication-Results // parseXGoogleDKIMResult parses Google DKIM result from Authentication-Results
// Example: x-google-dkim=pass (2048-bit rsa key) header.d=1e100.net header.i=@1e100.net header.b=fauiPVZ6 // Example: x-google-dkim=pass (2048-bit rsa key) header.d=1e100.net header.i=@1e100.net header.b=fauiPVZ6
func (a *AuthenticationAnalyzer) parseXGoogleDKIMResult(part string) *api.AuthResult { func (a *AuthenticationAnalyzer) parseXGoogleDKIMResult(part string) *model.AuthResult {
result := &api.AuthResult{} result := &model.AuthResult{}
// Extract result (pass, fail, etc.) // Extract result (pass, fail, etc.)
re := regexp.MustCompile(`x-google-dkim=(\w+)`) re := regexp.MustCompile(`x-google-dkim=(\w+)`)
if matches := re.FindStringSubmatch(part); len(matches) > 1 { if matches := re.FindStringSubmatch(part); len(matches) > 1 {
resultStr := strings.ToLower(matches[1]) resultStr := strings.ToLower(matches[1])
result.Result = api.AuthResultResult(resultStr) result.Result = model.AuthResultResult(resultStr)
} }
// Extract domain (header.d or d) // Extract domain (header.d or d)
@ -54,15 +55,15 @@ func (a *AuthenticationAnalyzer) parseXGoogleDKIMResult(part string) *api.AuthRe
result.Selector = &selector result.Selector = &selector
} }
result.Details = api.PtrTo(strings.TrimPrefix(part, "x-google-dkim=")) result.Details = utils.PtrTo(strings.TrimPrefix(part, "x-google-dkim="))
return result return result
} }
func (a *AuthenticationAnalyzer) calculateXGoogleDKIMScore(results *api.AuthenticationResults) (score int) { func (a *AuthenticationAnalyzer) calculateXGoogleDKIMScore(results *model.AuthenticationResults) (score int) {
if results.XGoogleDkim != nil { if results.XGoogleDkim != nil {
switch results.XGoogleDkim.Result { switch results.XGoogleDkim.Result {
case api.AuthResultResultPass: case model.AuthResultResultPass:
// pass: don't alter the score // pass: don't alter the score
default: // fail default: // fail
return -100 return -100

14
pkg/analyzer/authentication_x_google_dkim_test.go
View file

@ -24,43 +24,43 @@ package analyzer
import ( import (
"testing" "testing"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
func TestParseXGoogleDKIMResult(t *testing.T) { func TestParseXGoogleDKIMResult(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
part string part string
expectedResult api.AuthResultResult expectedResult model.AuthResultResult
expectedDomain string expectedDomain string
expectedSelector string expectedSelector string
}{ }{
{ {
name: "x-google-dkim pass with domain", name: "x-google-dkim pass with domain",
part: "x-google-dkim=pass (2048-bit rsa key) header.d=1e100.net header.i=@1e100.net header.b=fauiPVZ6", part: "x-google-dkim=pass (2048-bit rsa key) header.d=1e100.net header.i=@1e100.net header.b=fauiPVZ6",
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
expectedDomain: "1e100.net", expectedDomain: "1e100.net",
}, },
{ {
name: "x-google-dkim pass with short form", name: "x-google-dkim pass with short form",
part: "x-google-dkim=pass d=gmail.com", part: "x-google-dkim=pass d=gmail.com",
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
expectedDomain: "gmail.com", expectedDomain: "gmail.com",
}, },
{ {
name: "x-google-dkim fail", name: "x-google-dkim fail",
part: "x-google-dkim=fail header.d=example.com", part: "x-google-dkim=fail header.d=example.com",
expectedResult: api.AuthResultResultFail, expectedResult: model.AuthResultResultFail,
expectedDomain: "example.com", expectedDomain: "example.com",
}, },
{ {
name: "x-google-dkim with minimal info", name: "x-google-dkim with minimal info",
part: "x-google-dkim=pass", part: "x-google-dkim=pass",
expectedResult: api.AuthResultResultPass, expectedResult: model.AuthResultResultPass,
}, },
} }
analyzer := NewAuthenticationAnalyzer() analyzer := NewAuthenticationAnalyzer("")
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {

97
pkg/analyzer/content.go
View file

@ -32,7 +32,8 @@ import (
"time" "time"
"unicode" "unicode"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
"golang.org/x/net/html" "golang.org/x/net/html"
) )
@ -728,16 +729,16 @@ func (c *ContentAnalyzer) normalizeText(text string) string {
} }
// GenerateContentAnalysis creates structured content analysis from results // GenerateContentAnalysis creates structured content analysis from results
func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *api.ContentAnalysis { func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *model.ContentAnalysis {
if results == nil { if results == nil {
return nil return nil
} }
analysis := &api.ContentAnalysis{ analysis := &model.ContentAnalysis{
HasHtml: api.PtrTo(results.HTMLContent != ""), HasHtml: utils.PtrTo(results.HTMLContent != ""),
HasPlaintext: api.PtrTo(results.TextContent != ""), HasPlaintext: utils.PtrTo(results.TextContent != ""),
HasUnsubscribeLink: api.PtrTo(results.HasUnsubscribe), HasUnsubscribeLink: utils.PtrTo(results.HasUnsubscribe),
UnsubscribeMethods: &[]api.ContentAnalysisUnsubscribeMethods{}, UnsubscribeMethods: &[]model.ContentAnalysisUnsubscribeMethods{},
} }
// Calculate text-to-image ratio (inverse of image-to-text) // Calculate text-to-image ratio (inverse of image-to-text)
@ -750,16 +751,16 @@ func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *api.
} }
// Build HTML issues // Build HTML issues
htmlIssues := []api.ContentIssue{} htmlIssues := []model.ContentIssue{}
// Add HTML parsing errors // Add HTML parsing errors
if !results.HTMLValid && len(results.HTMLErrors) > 0 { if !results.HTMLValid && len(results.HTMLErrors) > 0 {
for _, errMsg := range results.HTMLErrors { for _, errMsg := range results.HTMLErrors {
htmlIssues = append(htmlIssues, api.ContentIssue{ htmlIssues = append(htmlIssues, model.ContentIssue{
Type: api.BrokenHtml, Type: model.BrokenHtml,
Severity: api.ContentIssueSeverityHigh, Severity: model.ContentIssueSeverityHigh,
Message: errMsg, Message: errMsg,
Advice: api.PtrTo("Fix HTML structure errors to improve email rendering across clients"), Advice: utils.PtrTo("Fix HTML structure errors to improve email rendering across clients"),
}) })
} }
} }
@ -773,53 +774,53 @@ func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *api.
} }
} }
if missingAltCount > 0 { if missingAltCount > 0 {
htmlIssues = append(htmlIssues, api.ContentIssue{ htmlIssues = append(htmlIssues, model.ContentIssue{
Type: api.MissingAlt, Type: model.MissingAlt,
Severity: api.ContentIssueSeverityMedium, Severity: model.ContentIssueSeverityMedium,
Message: fmt.Sprintf("%d image(s) missing alt attributes", missingAltCount), Message: fmt.Sprintf("%d image(s) missing alt attributes", missingAltCount),
Advice: api.PtrTo("Add descriptive alt text to all images for better accessibility and deliverability"), Advice: utils.PtrTo("Add descriptive alt text to all images for better accessibility and deliverability"),
}) })
} }
} }
// Add excessive images issue // Add excessive images issue
if results.ImageTextRatio > 10.0 { if results.ImageTextRatio > 10.0 {
htmlIssues = append(htmlIssues, api.ContentIssue{ htmlIssues = append(htmlIssues, model.ContentIssue{
Type: api.ExcessiveImages, Type: model.ExcessiveImages,
Severity: api.ContentIssueSeverityMedium, Severity: model.ContentIssueSeverityMedium,
Message: "Email is excessively image-heavy", Message: "Email is excessively image-heavy",
Advice: api.PtrTo("Reduce the number of images relative to text content"), Advice: utils.PtrTo("Reduce the number of images relative to text content"),
}) })
} }
// Add suspicious URL issues // Add suspicious URL issues
for _, suspURL := range results.SuspiciousURLs { for _, suspURL := range results.SuspiciousURLs {
htmlIssues = append(htmlIssues, api.ContentIssue{ htmlIssues = append(htmlIssues, model.ContentIssue{
Type: api.SuspiciousLink, Type: model.SuspiciousLink,
Severity: api.ContentIssueSeverityHigh, Severity: model.ContentIssueSeverityHigh,
Message: "Suspicious URL detected", Message: "Suspicious URL detected",
Location: &suspURL, Location: &suspURL,
Advice: api.PtrTo("Avoid URL shorteners, IP addresses, and obfuscated URLs in emails"), Advice: utils.PtrTo("Avoid URL shorteners, IP addresses, and obfuscated URLs in emails"),
}) })
} }
// Add harmful HTML tag issues // Add harmful HTML tag issues
for _, harmfulIssue := range results.HarmfullIssues { for _, harmfulIssue := range results.HarmfullIssues {
htmlIssues = append(htmlIssues, api.ContentIssue{ htmlIssues = append(htmlIssues, model.ContentIssue{
Type: api.DangerousHtml, Type: model.DangerousHtml,
Severity: api.ContentIssueSeverityCritical, Severity: model.ContentIssueSeverityCritical,
Message: harmfulIssue, Message: harmfulIssue,
Advice: api.PtrTo("Remove dangerous HTML tags like <script>, <iframe>, <object>, <embed>, <applet>, <form>, and <base> from email content"), Advice: utils.PtrTo("Remove dangerous HTML tags like <script>, <iframe>, <object>, <embed>, <applet>, <form>, and <base> from email content"),
}) })
} }
// Add general content issues (like external stylesheets) // Add general content issues (like external stylesheets)
for _, contentIssue := range results.ContentIssues { for _, contentIssue := range results.ContentIssues {
htmlIssues = append(htmlIssues, api.ContentIssue{ htmlIssues = append(htmlIssues, model.ContentIssue{
Type: api.BrokenHtml, Type: model.BrokenHtml,
Severity: api.ContentIssueSeverityLow, Severity: model.ContentIssueSeverityLow,
Message: contentIssue, Message: contentIssue,
Advice: api.PtrTo("Use inline CSS instead of external stylesheets for better email compatibility"), Advice: utils.PtrTo("Use inline CSS instead of external stylesheets for better email compatibility"),
}) })
} }
@ -829,31 +830,31 @@ func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *api.
// Convert links // Convert links
if len(results.Links) > 0 { if len(results.Links) > 0 {
links := make([]api.LinkCheck, 0, len(results.Links)) links := make([]model.LinkCheck, 0, len(results.Links))
for _, link := range results.Links { for _, link := range results.Links {
status := api.Valid status := model.Valid
if link.Status >= 400 { if link.Status >= 400 {
status = api.Broken status = model.Broken
} else if !link.IsSafe { } else if !link.IsSafe {
status = api.Suspicious status = model.Suspicious
} else if link.Warning != "" { } else if link.Warning != "" {
status = api.Timeout status = model.Timeout
} }
apiLink := api.LinkCheck{ apiLink := model.LinkCheck{
Url: link.URL, Url: link.URL,
Status: status, Status: status,
} }
if link.Status > 0 { if link.Status > 0 {
apiLink.HttpCode = api.PtrTo(link.Status) apiLink.HttpCode = utils.PtrTo(link.Status)
} }
// Check if it's a URL shortener // Check if it's a URL shortener
parsedURL, err := url.Parse(link.URL) parsedURL, err := url.Parse(link.URL)
if err == nil { if err == nil {
isShortened := c.isSuspiciousURL(link.URL, parsedURL) isShortened := c.isSuspiciousURL(link.URL, parsedURL)
apiLink.IsShortened = api.PtrTo(isShortened) apiLink.IsShortened = utils.PtrTo(isShortened)
} }
links = append(links, apiLink) links = append(links, apiLink)
@ -863,9 +864,9 @@ func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *api.
// Convert images // Convert images
if len(results.Images) > 0 { if len(results.Images) > 0 {
images := make([]api.ImageCheck, 0, len(results.Images)) images := make([]model.ImageCheck, 0, len(results.Images))
for _, img := range results.Images { for _, img := range results.Images {
apiImg := api.ImageCheck{ apiImg := model.ImageCheck{
HasAlt: img.HasAlt, HasAlt: img.HasAlt,
} }
if img.Src != "" { if img.Src != "" {
@ -875,7 +876,7 @@ func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *api.
apiImg.AltText = &img.AltText apiImg.AltText = &img.AltText
} }
// Simple heuristic: tracking pixels are typically 1x1 // Simple heuristic: tracking pixels are typically 1x1
apiImg.IsTrackingPixel = api.PtrTo(false) apiImg.IsTrackingPixel = utils.PtrTo(false)
images = append(images, apiImg) images = append(images, apiImg)
} }
@ -884,19 +885,19 @@ func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *api.
// Unsubscribe methods // Unsubscribe methods
if results.HasUnsubscribe { if results.HasUnsubscribe {
*analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, api.Link) *analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, model.Link)
} }
for _, url := range c.listUnsubscribeURLs { for _, url := range c.listUnsubscribeURLs {
if strings.HasPrefix(url, "mailto:") { if strings.HasPrefix(url, "mailto:") {
*analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, api.Mailto) *analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, model.Mailto)
} else if strings.HasPrefix(url, "http:") || strings.HasPrefix(url, "https:") { } else if strings.HasPrefix(url, "http:") || strings.HasPrefix(url, "https:") {
*analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, api.ListUnsubscribeHeader) *analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, model.ListUnsubscribeHeader)
} }
} }
if slices.Contains(*analysis.UnsubscribeMethods, api.ListUnsubscribeHeader) && c.hasOneClickUnsubscribe { if slices.Contains(*analysis.UnsubscribeMethods, model.ListUnsubscribeHeader) && c.hasOneClickUnsubscribe {
*analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, api.OneClick) *analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, model.OneClick)
} }
return analysis return analysis

35
pkg/analyzer/dns.go
View file

@ -24,7 +24,7 @@ package analyzer
import ( import (
"time" "time"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
// DNSAnalyzer analyzes DNS records for email domains // DNSAnalyzer analyzes DNS records for email domains
@ -54,16 +54,16 @@ func NewDNSAnalyzerWithResolver(timeout time.Duration, resolver DNSResolver) *DN
} }
// AnalyzeDNS performs DNS validation for the email's domain // AnalyzeDNS performs DNS validation for the email's domain
func (d *DNSAnalyzer) AnalyzeDNS(email *EmailMessage, authResults *api.AuthenticationResults, headersResults *api.HeaderAnalysis) *api.DNSResults { func (d *DNSAnalyzer) AnalyzeDNS(email *EmailMessage, headersResults *model.HeaderAnalysis) *model.DNSResults {
// Extract domain from From address // Extract domain from From address
if headersResults.DomainAlignment.FromDomain == nil || *headersResults.DomainAlignment.FromDomain == "" { if headersResults.DomainAlignment.FromDomain == nil || *headersResults.DomainAlignment.FromDomain == "" {
return &api.DNSResults{ return &model.DNSResults{
Errors: &[]string{"Unable to extract domain from email"}, Errors: &[]string{"Unable to extract domain from email"},
} }
} }
fromDomain := *headersResults.DomainAlignment.FromDomain fromDomain := *headersResults.DomainAlignment.FromDomain
results := &api.DNSResults{ results := &model.DNSResults{
FromDomain: fromDomain, FromDomain: fromDomain,
RpDomain: headersResults.DomainAlignment.ReturnPathDomain, RpDomain: headersResults.DomainAlignment.ReturnPathDomain,
} }
@ -104,19 +104,14 @@ func (d *DNSAnalyzer) AnalyzeDNS(email *EmailMessage, authResults *api.Authentic
// SPF validates the MAIL FROM command, which corresponds to Return-Path // SPF validates the MAIL FROM command, which corresponds to Return-Path
results.SpfRecords = d.checkSPFRecords(spfDomain) results.SpfRecords = d.checkSPFRecords(spfDomain)
// Check DKIM records (from authentication results) // Check DKIM records by parsing DKIM-Signature headers directly
// DKIM can be for any domain, but typically the From domain for _, sig := range parseDKIMSignatures(email.Header["Dkim-Signature"]) {
if authResults != nil && authResults.Dkim != nil { dkimRecord := d.checkDKIMRecord(sig.Domain, sig.Selector)
for _, dkim := range *authResults.Dkim { if dkimRecord != nil {
if dkim.Domain != nil && dkim.Selector != nil { if results.DkimRecords == nil {
dkimRecord := d.checkDKIMRecord(*dkim.Domain, *dkim.Selector) results.DkimRecords = new([]model.DKIMRecord)
if dkimRecord != nil {
if results.DkimRecords == nil {
results.DkimRecords = new([]api.DKIMRecord)
}
*results.DkimRecords = append(*results.DkimRecords, *dkimRecord)
}
} }
*results.DkimRecords = append(*results.DkimRecords, *dkimRecord)
} }
} }
@ -132,8 +127,8 @@ func (d *DNSAnalyzer) AnalyzeDNS(email *EmailMessage, authResults *api.Authentic
// AnalyzeDomainOnly performs DNS validation for a domain without email context // AnalyzeDomainOnly performs DNS validation for a domain without email context
// This is useful for checking domain configuration without sending an actual email // This is useful for checking domain configuration without sending an actual email
func (d *DNSAnalyzer) AnalyzeDomainOnly(domain string) *api.DNSResults { func (d *DNSAnalyzer) AnalyzeDomainOnly(domain string) *model.DNSResults {
results := &api.DNSResults{ results := &model.DNSResults{
FromDomain: domain, FromDomain: domain,
} }
@ -155,7 +150,7 @@ func (d *DNSAnalyzer) AnalyzeDomainOnly(domain string) *api.DNSResults {
// CalculateDomainOnlyScore calculates the DNS score for domain-only tests // CalculateDomainOnlyScore calculates the DNS score for domain-only tests
// Returns a score from 0-100 where higher is better // Returns a score from 0-100 where higher is better
// This version excludes PTR and DKIM checks since they require email context // This version excludes PTR and DKIM checks since they require email context
func (d *DNSAnalyzer) CalculateDomainOnlyScore(results *api.DNSResults) (int, string) { func (d *DNSAnalyzer) CalculateDomainOnlyScore(results *model.DNSResults) (int, string) {
if results == nil { if results == nil {
return 0, "" return 0, ""
} }
@ -197,7 +192,7 @@ func (d *DNSAnalyzer) CalculateDomainOnlyScore(results *api.DNSResults) (int, st
// CalculateDNSScore calculates the DNS score from records results // CalculateDNSScore calculates the DNS score from records results
// Returns a score from 0-100 where higher is better // Returns a score from 0-100 where higher is better
// senderIP is the original sender IP address used for FCrDNS verification // senderIP is the original sender IP address used for FCrDNS verification
func (d *DNSAnalyzer) CalculateDNSScore(results *api.DNSResults, senderIP string) (int, string) { func (d *DNSAnalyzer) CalculateDNSScore(results *model.DNSResults, senderIP string) (int, string) {
if results == nil { if results == nil {
return 0, "" return 0, ""
} }

19
pkg/analyzer/dns_bimi.go
View file

@ -27,11 +27,12 @@ import (
"regexp" "regexp"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// checkBIMIRecord looks up and validates BIMI record for a domain and selector // checkBIMIRecord looks up and validates BIMI record for a domain and selector
func (d *DNSAnalyzer) checkBIMIRecord(domain, selector string) *api.BIMIRecord { func (d *DNSAnalyzer) checkBIMIRecord(domain, selector string) *model.BIMIRecord {
// BIMI records are at: selector._bimi.domain // BIMI records are at: selector._bimi.domain
bimiDomain := fmt.Sprintf("%s._bimi.%s", selector, domain) bimiDomain := fmt.Sprintf("%s._bimi.%s", selector, domain)
@ -40,20 +41,20 @@ func (d *DNSAnalyzer) checkBIMIRecord(domain, selector string) *api.BIMIRecord {
txtRecords, err := d.resolver.LookupTXT(ctx, bimiDomain) txtRecords, err := d.resolver.LookupTXT(ctx, bimiDomain)
if err != nil { if err != nil {
return &api.BIMIRecord{ return &model.BIMIRecord{
Selector: selector, Selector: selector,
Domain: domain, Domain: domain,
Valid: false, Valid: false,
Error: api.PtrTo(fmt.Sprintf("Failed to lookup BIMI record: %v", err)), Error: utils.PtrTo(fmt.Sprintf("Failed to lookup BIMI record: %v", err)),
} }
} }
if len(txtRecords) == 0 { if len(txtRecords) == 0 {
return &api.BIMIRecord{ return &model.BIMIRecord{
Selector: selector, Selector: selector,
Domain: domain, Domain: domain,
Valid: false, Valid: false,
Error: api.PtrTo("No BIMI record found"), Error: utils.PtrTo("No BIMI record found"),
} }
} }
@ -66,18 +67,18 @@ func (d *DNSAnalyzer) checkBIMIRecord(domain, selector string) *api.BIMIRecord {
// Basic validation - should contain "v=BIMI1" and "l=" (logo URL) // Basic validation - should contain "v=BIMI1" and "l=" (logo URL)
if !d.validateBIMI(bimiRecord) { if !d.validateBIMI(bimiRecord) {
return &api.BIMIRecord{ return &model.BIMIRecord{
Selector: selector, Selector: selector,
Domain: domain, Domain: domain,
Record: &bimiRecord, Record: &bimiRecord,
LogoUrl: &logoURL, LogoUrl: &logoURL,
VmcUrl: &vmcURL, VmcUrl: &vmcURL,
Valid: false, Valid: false,
Error: api.PtrTo("BIMI record appears malformed"), Error: utils.PtrTo("BIMI record appears malformed"),
} }
} }
return &api.BIMIRecord{ return &model.BIMIRecord{
Selector: selector, Selector: selector,
Domain: domain, Domain: domain,
Record: &bimiRecord, Record: &bimiRecord,

57
pkg/analyzer/dns_dkim.go
View file

@ -26,11 +26,44 @@ import (
"fmt" "fmt"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// checkapi.DKIMRecord looks up and validates DKIM record for a domain and selector // DKIMHeader holds the domain and selector extracted from a DKIM-Signature header.
func (d *DNSAnalyzer) checkDKIMRecord(domain, selector string) *api.DKIMRecord { type DKIMHeader struct {
Domain string
Selector string
}
// parseDKIMSignatures extracts domain and selector from DKIM-Signature header values.
func parseDKIMSignatures(signatures []string) []DKIMHeader {
var results []DKIMHeader
for _, sig := range signatures {
var domain, selector string
for _, part := range strings.Split(sig, ";") {
kv := strings.SplitN(strings.TrimSpace(part), "=", 2)
if len(kv) != 2 {
continue
}
key := strings.TrimSpace(kv[0])
val := strings.TrimSpace(kv[1])
switch key {
case "d":
domain = val
case "s":
selector = val
}
}
if domain != "" && selector != "" {
results = append(results, DKIMHeader{Domain: domain, Selector: selector})
}
}
return results
}
// checkmodel.DKIMRecord looks up and validates DKIM record for a domain and selector
func (d *DNSAnalyzer) checkDKIMRecord(domain, selector string) *model.DKIMRecord {
// DKIM records are at: selector._domainkey.domain // DKIM records are at: selector._domainkey.domain
dkimDomain := fmt.Sprintf("%s._domainkey.%s", selector, domain) dkimDomain := fmt.Sprintf("%s._domainkey.%s", selector, domain)
@ -39,20 +72,20 @@ func (d *DNSAnalyzer) checkDKIMRecord(domain, selector string) *api.DKIMRecord {
txtRecords, err := d.resolver.LookupTXT(ctx, dkimDomain) txtRecords, err := d.resolver.LookupTXT(ctx, dkimDomain)
if err != nil { if err != nil {
return &api.DKIMRecord{ return &model.DKIMRecord{
Selector: selector, Selector: selector,
Domain: domain, Domain: domain,
Valid: false, Valid: false,
Error: api.PtrTo(fmt.Sprintf("Failed to lookup DKIM record: %v", err)), Error: utils.PtrTo(fmt.Sprintf("Failed to lookup DKIM record: %v", err)),
} }
} }
if len(txtRecords) == 0 { if len(txtRecords) == 0 {
return &api.DKIMRecord{ return &model.DKIMRecord{
Selector: selector, Selector: selector,
Domain: domain, Domain: domain,
Valid: false, Valid: false,
Error: api.PtrTo("No DKIM record found"), Error: utils.PtrTo("No DKIM record found"),
} }
} }
@ -61,16 +94,16 @@ func (d *DNSAnalyzer) checkDKIMRecord(domain, selector string) *api.DKIMRecord {
// Basic validation - should contain "v=DKIM1" and "p=" (public key) // Basic validation - should contain "v=DKIM1" and "p=" (public key)
if !d.validateDKIM(dkimRecord) { if !d.validateDKIM(dkimRecord) {
return &api.DKIMRecord{ return &model.DKIMRecord{
Selector: selector, Selector: selector,
Domain: domain, Domain: domain,
Record: api.PtrTo(dkimRecord), Record: utils.PtrTo(dkimRecord),
Valid: false, Valid: false,
Error: api.PtrTo("DKIM record appears malformed"), Error: utils.PtrTo("DKIM record appears malformed"),
} }
} }
return &api.DKIMRecord{ return &model.DKIMRecord{
Selector: selector, Selector: selector,
Domain: domain, Domain: domain,
Record: &dkimRecord, Record: &dkimRecord,
@ -94,7 +127,7 @@ func (d *DNSAnalyzer) validateDKIM(record string) bool {
return true return true
} }
func (d *DNSAnalyzer) calculateDKIMScore(results *api.DNSResults) (score int) { func (d *DNSAnalyzer) calculateDKIMScore(results *model.DNSResults) (score int) {
// DKIM provides strong email authentication // DKIM provides strong email authentication
if results.DkimRecords != nil && len(*results.DkimRecords) > 0 { if results.DkimRecords != nil && len(*results.DkimRecords) > 0 {
hasValidDKIM := false hasValidDKIM := false

214
pkg/analyzer/dns_dkim_test.go
View file

@ -26,6 +26,220 @@ import (
"time" "time"
) )
func TestParseDKIMSignatures(t *testing.T) {
tests := []struct {
name string
signatures []string
expected []DKIMHeader
}{
{
name: "Empty input",
signatures: nil,
expected: nil,
},
{
name: "Empty string",
signatures: []string{""},
expected: nil,
},
{
name: "Simple Gmail-style",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:subject:date:message-id; bh=abcdef1234567890=; b=SIGNATURE_DATA_HERE==`,
},
expected: []DKIMHeader{{Domain: "gmail.com", Selector: "20210112"}},
},
{
name: "Microsoft 365 style",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=contoso.com; s=selector1; h=From:Date:Subject:Message-ID; bh=UErATeHehIIPIXPeUA==; b=SIGNATURE_DATA==`,
},
expected: []DKIMHeader{{Domain: "contoso.com", Selector: "selector1"}},
},
{
name: "Tab-folded multiline (Postfix-style)",
signatures: []string{
"v=1; a=rsa-sha256; c=relaxed/simple; d=nemunai.re; s=thot;\r\n\tt=1760866834; bh=YNB7c8Qgm8YGn9X1FAXTcdpO7t4YSZFiMrmpCfD/3zw=;\r\n\th=From:To:Subject;\r\n\tb=T4TFaypMpsHGYCl3PGLwmzOYRF11rYjC7lF8V5VFU+ldvG8WBpFn==",
},
expected: []DKIMHeader{{Domain: "nemunai.re", Selector: "thot"}},
},
{
name: "Space-folded multiline (RFC-style)",
signatures: []string{
"v=1; a=rsa-sha256; c=relaxed/relaxed;\r\n d=football.example.com; i=@football.example.com;\r\n q=dns/txt; s=test; t=1528637909; h=from:to:subject;\r\n bh=2jUSOH9NhtVGCQWNr9BrIAPreKQjO6Sn7XIkfJVOzv8=;\r\n b=F45dVWDfMbQDGHJFlXUNB2HKfbCeLRyhDXgFpEL8Gwps==",
},
expected: []DKIMHeader{{Domain: "football.example.com", Selector: "test"}},
},
{
name: "d= and s= on separate continuation lines",
signatures: []string{
"v=1; a=rsa-sha256;\r\n\tc=relaxed/relaxed;\r\n\td=mycompany.com;\r\n\ts=selector1;\r\n\tbh=hash=;\r\n\tb=sig==",
},
expected: []DKIMHeader{{Domain: "mycompany.com", Selector: "selector1"}},
},
{
name: "No space after semicolons",
signatures: []string{
`v=1;a=rsa-sha256;c=relaxed/relaxed;d=example.net;s=mail;h=from:to:subject;bh=abc=;b=xyz==`,
},
expected: []DKIMHeader{{Domain: "example.net", Selector: "mail"}},
},
{
name: "Multiple spaces after semicolons",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=example.com; s=myselector; bh=hash=; b=sig==`,
},
expected: []DKIMHeader{{Domain: "example.com", Selector: "myselector"}},
},
{
name: "Ed25519 signature (RFC 8463)",
signatures: []string{
"v=1; a=ed25519-sha256; c=relaxed/relaxed;\r\n d=football.example.com; i=@football.example.com;\r\n q=dns/txt; s=brisbane; t=1528637909; h=from:to:subject;\r\n bh=2jUSOH9NhtVGCQWNr9BrIAPreKQjO6Sn7XIkfJVOzv8=;\r\n b=/gCrinpcQOoIfuHNQIbq4pgh9kyIK3AQ==",
},
expected: []DKIMHeader{{Domain: "football.example.com", Selector: "brisbane"}},
},
{
name: "Multiple signatures (ESP double-signing)",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=mydomain.com; s=mail; h=from:to:subject; bh=hash1=; b=sig1==`,
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=sendib.com; s=mail; h=from:to:subject; bh=hash1=; b=sig2==`,
},
expected: []DKIMHeader{
{Domain: "mydomain.com", Selector: "mail"},
{Domain: "sendib.com", Selector: "mail"},
},
},
{
name: "Dual-algorithm signing (Ed25519 + RSA, same domain, different selectors)",
signatures: []string{
`v=1; a=ed25519-sha256; c=relaxed/relaxed; d=football.example.com; s=brisbane; h=from:to:subject; bh=hash=; b=edSig==`,
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=football.example.com; s=test; h=from:to:subject; bh=hash=; b=rsaSig==`,
},
expected: []DKIMHeader{
{Domain: "football.example.com", Selector: "brisbane"},
{Domain: "football.example.com", Selector: "test"},
},
},
{
name: "Amazon SES long selectors",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/simple; d=amazonses.com; s=224i4yxa5dv7c2xz3womw6peuabd; h=from:to:subject; bh=sesHash=; b=sesSig==`,
`v=1; a=rsa-sha256; c=relaxed/simple; d=customerdomain.io; s=ug7nbtf4gccmlpwj322ax3p6ow6fovbt; h=from:to:subject; bh=sesHash=; b=customSig==`,
},
expected: []DKIMHeader{
{Domain: "amazonses.com", Selector: "224i4yxa5dv7c2xz3womw6peuabd"},
{Domain: "customerdomain.io", Selector: "ug7nbtf4gccmlpwj322ax3p6ow6fovbt"},
},
},
{
name: "Subdomain in d=",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=mail.example.co.uk; s=dkim2025; h=from:to:subject; bh=hash=; b=sig==`,
},
expected: []DKIMHeader{{Domain: "mail.example.co.uk", Selector: "dkim2025"}},
},
{
name: "Deeply nested subdomain",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=bounce.transactional.mail.example.com; s=s2048; h=from:to:subject; bh=hash=; b=sig==`,
},
expected: []DKIMHeader{{Domain: "bounce.transactional.mail.example.com", Selector: "s2048"}},
},
{
name: "Selector with hyphens (Microsoft 365 custom domain style)",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=example.com; s=selector1-contoso-com; h=from:to:subject; bh=hash=; b=sig==`,
},
expected: []DKIMHeader{{Domain: "example.com", Selector: "selector1-contoso-com"}},
},
{
name: "Selector with dots",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=example.com; s=smtp.mail; h=from:to:subject; bh=hash=; b=sig==`,
},
expected: []DKIMHeader{{Domain: "example.com", Selector: "smtp.mail"}},
},
{
name: "Single-character selector",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=tiny.io; s=x; h=from:to:subject; bh=hash=; b=sig==`,
},
expected: []DKIMHeader{{Domain: "tiny.io", Selector: "x"}},
},
{
name: "Postmark-style timestamp selector, s= before d=",
signatures: []string{
`v=1; a=rsa-sha1; c=relaxed/relaxed; s=20130519032151pm; d=postmarkapp.com; h=From:Date:Subject; bh=vYFvy46eesUDGJ45hyBTH30JfN4=; b=iHeFQ+7rCiSQs3DPjR2eUSZSv4i==`,
},
expected: []DKIMHeader{{Domain: "postmarkapp.com", Selector: "20130519032151pm"}},
},
{
name: "d= and s= at the very end",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; h=from:to:subject; bh=hash=; b=sig==; d=example.net; s=trailing`,
},
expected: []DKIMHeader{{Domain: "example.net", Selector: "trailing"}},
},
{
name: "Full tag set",
signatures: []string{
`v=1; a=rsa-sha256; d=example.com; s=selector1; c=relaxed/simple; q=dns/txt; i=user@example.com; t=1255993973; x=1256598773; h=From:Sender:Reply-To:Subject:Date:Message-Id:To:Cc; bh=+7qxGePcmmrtZAIVQAtkSSGHfQ/ftNuvUTWJ3vXC9Zc=; b=dB85+qM+If1KGQmqMLNpqLgNtUaG5dhGjYjQD6/QXtXmViJx8tf9gLEjcHr+musLCAvr0Fsn1DA3ZLLlUxpf4AR==`,
},
expected: []DKIMHeader{{Domain: "example.com", Selector: "selector1"}},
},
{
name: "Missing d= tag",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; s=selector1; h=from:to; bh=hash=; b=sig==`,
},
expected: nil,
},
{
name: "Missing s= tag",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=example.com; h=from:to; bh=hash=; b=sig==`,
},
expected: nil,
},
{
name: "Missing both d= and s= tags",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; h=from:to; bh=hash=; b=sig==`,
},
expected: nil,
},
{
name: "Mix of valid and invalid signatures",
signatures: []string{
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=good.com; s=sel1; h=from:to; bh=hash=; b=sig==`,
`v=1; a=rsa-sha256; c=relaxed/relaxed; s=orphan; h=from:to; bh=hash=; b=sig==`,
`v=1; a=rsa-sha256; c=relaxed/relaxed; d=also-good.com; s=sel2; h=from:to; bh=hash=; b=sig==`,
},
expected: []DKIMHeader{
{Domain: "good.com", Selector: "sel1"},
{Domain: "also-good.com", Selector: "sel2"},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := parseDKIMSignatures(tt.signatures)
if len(result) != len(tt.expected) {
t.Fatalf("parseDKIMSignatures() returned %d results, want %d\n got: %+v\n want: %+v", len(result), len(tt.expected), result, tt.expected)
}
for i := range tt.expected {
if result[i].Domain != tt.expected[i].Domain {
t.Errorf("result[%d].Domain = %q, want %q", i, result[i].Domain, tt.expected[i].Domain)
}
if result[i].Selector != tt.expected[i].Selector {
t.Errorf("result[%d].Selector = %q, want %q", i, result[i].Selector, tt.expected[i].Selector)
}
}
})
}
}
func TestValidateDKIM(t *testing.T) { func TestValidateDKIM(t *testing.T) {
tests := []struct { tests := []struct {
name string name string

51
pkg/analyzer/dns_dmarc.go
View file

@ -27,11 +27,12 @@ import (
"regexp" "regexp"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// checkapi.DMARCRecord looks up and validates DMARC record for a domain // checkmodel.DMARCRecord looks up and validates DMARC record for a domain
func (d *DNSAnalyzer) checkDMARCRecord(domain string) *api.DMARCRecord { func (d *DNSAnalyzer) checkDMARCRecord(domain string) *model.DMARCRecord {
// DMARC records are at: _dmarc.domain // DMARC records are at: _dmarc.domain
dmarcDomain := fmt.Sprintf("_dmarc.%s", domain) dmarcDomain := fmt.Sprintf("_dmarc.%s", domain)
@ -40,9 +41,9 @@ func (d *DNSAnalyzer) checkDMARCRecord(domain string) *api.DMARCRecord {
txtRecords, err := d.resolver.LookupTXT(ctx, dmarcDomain) txtRecords, err := d.resolver.LookupTXT(ctx, dmarcDomain)
if err != nil { if err != nil {
return &api.DMARCRecord{ return &model.DMARCRecord{
Valid: false, Valid: false,
Error: api.PtrTo(fmt.Sprintf("Failed to lookup DMARC record: %v", err)), Error: utils.PtrTo(fmt.Sprintf("Failed to lookup DMARC record: %v", err)),
} }
} }
@ -56,9 +57,9 @@ func (d *DNSAnalyzer) checkDMARCRecord(domain string) *api.DMARCRecord {
} }
if dmarcRecord == "" { if dmarcRecord == "" {
return &api.DMARCRecord{ return &model.DMARCRecord{
Valid: false, Valid: false,
Error: api.PtrTo("No DMARC record found"), Error: utils.PtrTo("No DMARC record found"),
} }
} }
@ -77,21 +78,21 @@ func (d *DNSAnalyzer) checkDMARCRecord(domain string) *api.DMARCRecord {
// Basic validation // Basic validation
if !d.validateDMARC(dmarcRecord) { if !d.validateDMARC(dmarcRecord) {
return &api.DMARCRecord{ return &model.DMARCRecord{
Record: &dmarcRecord, Record: &dmarcRecord,
Policy: api.PtrTo(api.DMARCRecordPolicy(policy)), Policy: utils.PtrTo(model.DMARCRecordPolicy(policy)),
SubdomainPolicy: subdomainPolicy, SubdomainPolicy: subdomainPolicy,
Percentage: percentage, Percentage: percentage,
SpfAlignment: spfAlignment, SpfAlignment: spfAlignment,
DkimAlignment: dkimAlignment, DkimAlignment: dkimAlignment,
Valid: false, Valid: false,
Error: api.PtrTo("DMARC record appears malformed"), Error: utils.PtrTo("DMARC record appears malformed"),
} }
} }
return &api.DMARCRecord{ return &model.DMARCRecord{
Record: &dmarcRecord, Record: &dmarcRecord,
Policy: api.PtrTo(api.DMARCRecordPolicy(policy)), Policy: utils.PtrTo(model.DMARCRecordPolicy(policy)),
SubdomainPolicy: subdomainPolicy, SubdomainPolicy: subdomainPolicy,
Percentage: percentage, Percentage: percentage,
SpfAlignment: spfAlignment, SpfAlignment: spfAlignment,
@ -113,44 +114,44 @@ func (d *DNSAnalyzer) extractDMARCPolicy(record string) string {
// extractDMARCSPFAlignment extracts SPF alignment mode from a DMARC record // extractDMARCSPFAlignment extracts SPF alignment mode from a DMARC record
// Returns "relaxed" (default) or "strict" // Returns "relaxed" (default) or "strict"
func (d *DNSAnalyzer) extractDMARCSPFAlignment(record string) *api.DMARCRecordSpfAlignment { func (d *DNSAnalyzer) extractDMARCSPFAlignment(record string) *model.DMARCRecordSpfAlignment {
// Look for aspf=s (strict) or aspf=r (relaxed) // Look for aspf=s (strict) or aspf=r (relaxed)
re := regexp.MustCompile(`aspf=(r|s)`) re := regexp.MustCompile(`aspf=(r|s)`)
matches := re.FindStringSubmatch(record) matches := re.FindStringSubmatch(record)
if len(matches) > 1 { if len(matches) > 1 {
if matches[1] == "s" { if matches[1] == "s" {
return api.PtrTo(api.DMARCRecordSpfAlignmentStrict) return utils.PtrTo(model.DMARCRecordSpfAlignmentStrict)
} }
return api.PtrTo(api.DMARCRecordSpfAlignmentRelaxed) return utils.PtrTo(model.DMARCRecordSpfAlignmentRelaxed)
} }
// Default is relaxed if not specified // Default is relaxed if not specified
return api.PtrTo(api.DMARCRecordSpfAlignmentRelaxed) return utils.PtrTo(model.DMARCRecordSpfAlignmentRelaxed)
} }
// extractDMARCDKIMAlignment extracts DKIM alignment mode from a DMARC record // extractDMARCDKIMAlignment extracts DKIM alignment mode from a DMARC record
// Returns "relaxed" (default) or "strict" // Returns "relaxed" (default) or "strict"
func (d *DNSAnalyzer) extractDMARCDKIMAlignment(record string) *api.DMARCRecordDkimAlignment { func (d *DNSAnalyzer) extractDMARCDKIMAlignment(record string) *model.DMARCRecordDkimAlignment {
// Look for adkim=s (strict) or adkim=r (relaxed) // Look for adkim=s (strict) or adkim=r (relaxed)
re := regexp.MustCompile(`adkim=(r|s)`) re := regexp.MustCompile(`adkim=(r|s)`)
matches := re.FindStringSubmatch(record) matches := re.FindStringSubmatch(record)
if len(matches) > 1 { if len(matches) > 1 {
if matches[1] == "s" { if matches[1] == "s" {
return api.PtrTo(api.DMARCRecordDkimAlignmentStrict) return utils.PtrTo(model.DMARCRecordDkimAlignmentStrict)
} }
return api.PtrTo(api.DMARCRecordDkimAlignmentRelaxed) return utils.PtrTo(model.DMARCRecordDkimAlignmentRelaxed)
} }
// Default is relaxed if not specified // Default is relaxed if not specified
return api.PtrTo(api.DMARCRecordDkimAlignmentRelaxed) return utils.PtrTo(model.DMARCRecordDkimAlignmentRelaxed)
} }
// extractDMARCSubdomainPolicy extracts subdomain policy from a DMARC record // extractDMARCSubdomainPolicy extracts subdomain policy from a DMARC record
// Returns the sp tag value or nil if not specified (defaults to main policy) // Returns the sp tag value or nil if not specified (defaults to main policy)
func (d *DNSAnalyzer) extractDMARCSubdomainPolicy(record string) *api.DMARCRecordSubdomainPolicy { func (d *DNSAnalyzer) extractDMARCSubdomainPolicy(record string) *model.DMARCRecordSubdomainPolicy {
// Look for sp=none, sp=quarantine, or sp=reject // Look for sp=none, sp=quarantine, or sp=reject
re := regexp.MustCompile(`sp=(none|quarantine|reject)`) re := regexp.MustCompile(`sp=(none|quarantine|reject)`)
matches := re.FindStringSubmatch(record) matches := re.FindStringSubmatch(record)
if len(matches) > 1 { if len(matches) > 1 {
return api.PtrTo(api.DMARCRecordSubdomainPolicy(matches[1])) return utils.PtrTo(model.DMARCRecordSubdomainPolicy(matches[1]))
} }
// If sp is not specified, it defaults to the main policy (p tag) // If sp is not specified, it defaults to the main policy (p tag)
// Return nil to indicate it's using the default // Return nil to indicate it's using the default
@ -191,7 +192,7 @@ func (d *DNSAnalyzer) validateDMARC(record string) bool {
return true return true
} }
func (d *DNSAnalyzer) calculateDMARCScore(results *api.DNSResults) (score int) { func (d *DNSAnalyzer) calculateDMARCScore(results *model.DNSResults) (score int) {
// DMARC ties SPF and DKIM together and provides policy // DMARC ties SPF and DKIM together and provides policy
if results.DmarcRecord != nil { if results.DmarcRecord != nil {
if results.DmarcRecord.Valid { if results.DmarcRecord.Valid {
@ -210,10 +211,10 @@ func (d *DNSAnalyzer) calculateDMARCScore(results *api.DNSResults) (score int) {
} }
} }
// Bonus points for strict alignment modes (2 points each) // Bonus points for strict alignment modes (2 points each)
if results.DmarcRecord.SpfAlignment != nil && *results.DmarcRecord.SpfAlignment == api.DMARCRecordSpfAlignmentStrict { if results.DmarcRecord.SpfAlignment != nil && *results.DmarcRecord.SpfAlignment == model.DMARCRecordSpfAlignmentStrict {
score += 5 score += 5
} }
if results.DmarcRecord.DkimAlignment != nil && *results.DmarcRecord.DkimAlignment == api.DMARCRecordDkimAlignmentStrict { if results.DmarcRecord.DkimAlignment != nil && *results.DmarcRecord.DkimAlignment == model.DMARCRecordDkimAlignmentStrict {
score += 5 score += 5
} }
// Subdomain policy scoring (sp tag) // Subdomain policy scoring (sp tag)

21
pkg/analyzer/dns_dmarc_test.go
View file

@ -25,7 +25,8 @@ import (
"testing" "testing"
"time" "time"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
func TestExtractDMARCPolicy(t *testing.T) { func TestExtractDMARCPolicy(t *testing.T) {
@ -228,17 +229,17 @@ func TestExtractDMARCSubdomainPolicy(t *testing.T) {
{ {
name: "Subdomain policy - none", name: "Subdomain policy - none",
record: "v=DMARC1; p=quarantine; sp=none", record: "v=DMARC1; p=quarantine; sp=none",
expectedPolicy: api.PtrTo("none"), expectedPolicy: utils.PtrTo("none"),
}, },
{ {
name: "Subdomain policy - quarantine", name: "Subdomain policy - quarantine",
record: "v=DMARC1; p=reject; sp=quarantine", record: "v=DMARC1; p=reject; sp=quarantine",
expectedPolicy: api.PtrTo("quarantine"), expectedPolicy: utils.PtrTo("quarantine"),
}, },
{ {
name: "Subdomain policy - reject", name: "Subdomain policy - reject",
record: "v=DMARC1; p=quarantine; sp=reject", record: "v=DMARC1; p=quarantine; sp=reject",
expectedPolicy: api.PtrTo("reject"), expectedPolicy: utils.PtrTo("reject"),
}, },
{ {
name: "No subdomain policy specified (defaults to main policy)", name: "No subdomain policy specified (defaults to main policy)",
@ -248,7 +249,7 @@ func TestExtractDMARCSubdomainPolicy(t *testing.T) {
{ {
name: "Complex record with subdomain policy", name: "Complex record with subdomain policy",
record: "v=DMARC1; p=reject; sp=quarantine; rua=mailto:dmarc@example.com; pct=100", record: "v=DMARC1; p=reject; sp=quarantine; rua=mailto:dmarc@example.com; pct=100",
expectedPolicy: api.PtrTo("quarantine"), expectedPolicy: utils.PtrTo("quarantine"),
}, },
} }
@ -282,22 +283,22 @@ func TestExtractDMARCPercentage(t *testing.T) {
{ {
name: "Percentage - 100", name: "Percentage - 100",
record: "v=DMARC1; p=quarantine; pct=100", record: "v=DMARC1; p=quarantine; pct=100",
expectedPercentage: api.PtrTo(100), expectedPercentage: utils.PtrTo(100),
}, },
{ {
name: "Percentage - 50", name: "Percentage - 50",
record: "v=DMARC1; p=quarantine; pct=50", record: "v=DMARC1; p=quarantine; pct=50",
expectedPercentage: api.PtrTo(50), expectedPercentage: utils.PtrTo(50),
}, },
{ {
name: "Percentage - 25", name: "Percentage - 25",
record: "v=DMARC1; p=reject; pct=25", record: "v=DMARC1; p=reject; pct=25",
expectedPercentage: api.PtrTo(25), expectedPercentage: utils.PtrTo(25),
}, },
{ {
name: "Percentage - 0", name: "Percentage - 0",
record: "v=DMARC1; p=none; pct=0", record: "v=DMARC1; p=none; pct=0",
expectedPercentage: api.PtrTo(0), expectedPercentage: utils.PtrTo(0),
}, },
{ {
name: "No percentage specified (defaults to 100)", name: "No percentage specified (defaults to 100)",
@ -307,7 +308,7 @@ func TestExtractDMARCPercentage(t *testing.T) {
{ {
name: "Complex record with percentage", name: "Complex record with percentage",
record: "v=DMARC1; p=reject; sp=quarantine; rua=mailto:dmarc@example.com; pct=75", record: "v=DMARC1; p=reject; sp=quarantine; rua=mailto:dmarc@example.com; pct=75",
expectedPercentage: api.PtrTo(75), expectedPercentage: utils.PtrTo(75),
}, },
{ {
name: "Invalid percentage > 100 (ignored)", name: "Invalid percentage > 100 (ignored)",

4
pkg/analyzer/dns_fcr.go
View file

@ -24,7 +24,7 @@ package analyzer
import ( import (
"context" "context"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
// checkPTRAndForward performs reverse DNS lookup (PTR) and forward confirmation (A/AAAA) // checkPTRAndForward performs reverse DNS lookup (PTR) and forward confirmation (A/AAAA)
@ -63,7 +63,7 @@ func (d *DNSAnalyzer) checkPTRAndForward(ip string) ([]string, []string) {
} }
// Proper reverse DNS (PTR) and forward-confirmed reverse DNS (FCrDNS) is important for deliverability // Proper reverse DNS (PTR) and forward-confirmed reverse DNS (FCrDNS) is important for deliverability
func (d *DNSAnalyzer) calculatePTRScore(results *api.DNSResults, senderIP string) (score int) { func (d *DNSAnalyzer) calculatePTRScore(results *model.DNSResults, senderIP string) (score int) {
if results.PtrRecords != nil && len(*results.PtrRecords) > 0 { if results.PtrRecords != nil && len(*results.PtrRecords) > 0 {
// 50 points for having PTR records // 50 points for having PTR records
score += 50 score += 50

19
pkg/analyzer/dns_mx.go
View file

@ -25,36 +25,37 @@ import (
"context" "context"
"fmt" "fmt"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// checkMXRecords looks up MX records for a domain // checkMXRecords looks up MX records for a domain
func (d *DNSAnalyzer) checkMXRecords(domain string) *[]api.MXRecord { func (d *DNSAnalyzer) checkMXRecords(domain string) *[]model.MXRecord {
ctx, cancel := context.WithTimeout(context.Background(), d.Timeout) ctx, cancel := context.WithTimeout(context.Background(), d.Timeout)
defer cancel() defer cancel()
mxRecords, err := d.resolver.LookupMX(ctx, domain) mxRecords, err := d.resolver.LookupMX(ctx, domain)
if err != nil { if err != nil {
return &[]api.MXRecord{ return &[]model.MXRecord{
{ {
Valid: false, Valid: false,
Error: api.PtrTo(fmt.Sprintf("Failed to lookup MX records: %v", err)), Error: utils.PtrTo(fmt.Sprintf("Failed to lookup MX records: %v", err)),
}, },
} }
} }
if len(mxRecords) == 0 { if len(mxRecords) == 0 {
return &[]api.MXRecord{ return &[]model.MXRecord{
{ {
Valid: false, Valid: false,
Error: api.PtrTo("No MX records found"), Error: utils.PtrTo("No MX records found"),
}, },
} }
} }
var results []api.MXRecord var results []model.MXRecord
for _, mx := range mxRecords { for _, mx := range mxRecords {
results = append(results, api.MXRecord{ results = append(results, model.MXRecord{
Host: mx.Host, Host: mx.Host,
Priority: mx.Pref, Priority: mx.Pref,
Valid: true, Valid: true,
@ -64,7 +65,7 @@ func (d *DNSAnalyzer) checkMXRecords(domain string) *[]api.MXRecord {
return &results return &results
} }
func (d *DNSAnalyzer) calculateMXScore(results *api.DNSResults) (score int) { func (d *DNSAnalyzer) calculateMXScore(results *model.DNSResults) (score int) {
// Having valid MX records is critical for email deliverability // Having valid MX records is critical for email deliverability
// From domain MX records (half points) - needed for replies // From domain MX records (half points) - needed for replies
if results.FromMxRecords != nil && len(*results.FromMxRecords) > 0 { if results.FromMxRecords != nil && len(*results.FromMxRecords) > 0 {

45
pkg/analyzer/dns_spf.go
View file

@ -27,33 +27,34 @@ import (
"regexp" "regexp"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// checkSPFRecords looks up and validates SPF records for a domain, including resolving include: directives // checkSPFRecords looks up and validates SPF records for a domain, including resolving include: directives
func (d *DNSAnalyzer) checkSPFRecords(domain string) *[]api.SPFRecord { func (d *DNSAnalyzer) checkSPFRecords(domain string) *[]model.SPFRecord {
visited := make(map[string]bool) visited := make(map[string]bool)
return d.resolveSPFRecords(domain, visited, 0, true) return d.resolveSPFRecords(domain, visited, 0, true)
} }
// resolveSPFRecords recursively resolves SPF records including include: directives // resolveSPFRecords recursively resolves SPF records including include: directives
// isMainRecord indicates if this is the primary domain's record (not an included one) // isMainRecord indicates if this is the primary domain's record (not an included one)
func (d *DNSAnalyzer) resolveSPFRecords(domain string, visited map[string]bool, depth int, isMainRecord bool) *[]api.SPFRecord { func (d *DNSAnalyzer) resolveSPFRecords(domain string, visited map[string]bool, depth int, isMainRecord bool) *[]model.SPFRecord {
const maxDepth = 10 // Prevent infinite recursion const maxDepth = 10 // Prevent infinite recursion
if depth > maxDepth { if depth > maxDepth {
return &[]api.SPFRecord{ return &[]model.SPFRecord{
{ {
Domain: &domain, Domain: &domain,
Valid: false, Valid: false,
Error: api.PtrTo("Maximum SPF include depth exceeded"), Error: utils.PtrTo("Maximum SPF include depth exceeded"),
}, },
} }
} }
// Prevent circular references // Prevent circular references
if visited[domain] { if visited[domain] {
return &[]api.SPFRecord{} return &[]model.SPFRecord{}
} }
visited[domain] = true visited[domain] = true
@ -62,11 +63,11 @@ func (d *DNSAnalyzer) resolveSPFRecords(domain string, visited map[string]bool,
txtRecords, err := d.resolver.LookupTXT(ctx, domain) txtRecords, err := d.resolver.LookupTXT(ctx, domain)
if err != nil { if err != nil {
return &[]api.SPFRecord{ return &[]model.SPFRecord{
{ {
Domain: &domain, Domain: &domain,
Valid: false, Valid: false,
Error: api.PtrTo(fmt.Sprintf("Failed to lookup TXT records: %v", err)), Error: utils.PtrTo(fmt.Sprintf("Failed to lookup TXT records: %v", err)),
}, },
} }
} }
@ -82,23 +83,23 @@ func (d *DNSAnalyzer) resolveSPFRecords(domain string, visited map[string]bool,
} }
if spfCount == 0 { if spfCount == 0 {
return &[]api.SPFRecord{ return &[]model.SPFRecord{
{ {
Domain: &domain, Domain: &domain,
Valid: false, Valid: false,
Error: api.PtrTo("No SPF record found"), Error: utils.PtrTo("No SPF record found"),
}, },
} }
} }
var results []api.SPFRecord var results []model.SPFRecord
if spfCount > 1 { if spfCount > 1 {
results = append(results, api.SPFRecord{ results = append(results, model.SPFRecord{
Domain: &domain, Domain: &domain,
Record: &spfRecord, Record: &spfRecord,
Valid: false, Valid: false,
Error: api.PtrTo("Multiple SPF records found (RFC violation)"), Error: utils.PtrTo("Multiple SPF records found (RFC violation)"),
}) })
return &results return &results
} }
@ -107,28 +108,28 @@ func (d *DNSAnalyzer) resolveSPFRecords(domain string, visited map[string]bool,
validationErr := d.validateSPF(spfRecord, isMainRecord) validationErr := d.validateSPF(spfRecord, isMainRecord)
// Extract the "all" mechanism qualifier // Extract the "all" mechanism qualifier
var allQualifier *api.SPFRecordAllQualifier var allQualifier *model.SPFRecordAllQualifier
var errMsg *string var errMsg *string
if validationErr != nil { if validationErr != nil {
errMsg = api.PtrTo(validationErr.Error()) errMsg = utils.PtrTo(validationErr.Error())
} else { } else {
// Extract qualifier from the "all" mechanism // Extract qualifier from the "all" mechanism
if strings.HasSuffix(spfRecord, " -all") { if strings.HasSuffix(spfRecord, " -all") {
allQualifier = api.PtrTo(api.SPFRecordAllQualifier("-")) allQualifier = utils.PtrTo(model.SPFRecordAllQualifier("-"))
} else if strings.HasSuffix(spfRecord, " ~all") { } else if strings.HasSuffix(spfRecord, " ~all") {
allQualifier = api.PtrTo(api.SPFRecordAllQualifier("~")) allQualifier = utils.PtrTo(model.SPFRecordAllQualifier("~"))
} else if strings.HasSuffix(spfRecord, " +all") { } else if strings.HasSuffix(spfRecord, " +all") {
allQualifier = api.PtrTo(api.SPFRecordAllQualifier("+")) allQualifier = utils.PtrTo(model.SPFRecordAllQualifier("+"))
} else if strings.HasSuffix(spfRecord, " ?all") { } else if strings.HasSuffix(spfRecord, " ?all") {
allQualifier = api.PtrTo(api.SPFRecordAllQualifier("?")) allQualifier = utils.PtrTo(model.SPFRecordAllQualifier("?"))
} else if strings.HasSuffix(spfRecord, " all") { } else if strings.HasSuffix(spfRecord, " all") {
// Implicit + qualifier (default) // Implicit + qualifier (default)
allQualifier = api.PtrTo(api.SPFRecordAllQualifier("+")) allQualifier = utils.PtrTo(model.SPFRecordAllQualifier("+"))
} }
} }
results = append(results, api.SPFRecord{ results = append(results, model.SPFRecord{
Domain: &domain, Domain: &domain,
Record: &spfRecord, Record: &spfRecord,
Valid: validationErr == nil, Valid: validationErr == nil,
@ -301,7 +302,7 @@ func (d *DNSAnalyzer) hasSPFStrictFail(record string) bool {
return strings.HasSuffix(record, " -all") return strings.HasSuffix(record, " -all")
} }
func (d *DNSAnalyzer) calculateSPFScore(results *api.DNSResults) (score int) { func (d *DNSAnalyzer) calculateSPFScore(results *model.DNSResults) (score int) {
// SPF is essential for email authentication // SPF is essential for email authentication
if results.SpfRecords != nil && len(*results.SpfRecords) > 0 { if results.SpfRecords != nil && len(*results.SpfRecords) > 0 {
// Find the main SPF record by skipping redirects // Find the main SPF record by skipping redirects

57
pkg/analyzer/headers.go
View file

@ -31,7 +31,8 @@ import (
"golang.org/x/net/publicsuffix" "golang.org/x/net/publicsuffix"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// HeaderAnalyzer analyzes email header quality and structure // HeaderAnalyzer analyzes email header quality and structure
@ -43,7 +44,7 @@ func NewHeaderAnalyzer() *HeaderAnalyzer {
} }
// CalculateHeaderScore evaluates email structural quality from header analysis // CalculateHeaderScore evaluates email structural quality from header analysis
func (h *HeaderAnalyzer) CalculateHeaderScore(analysis *api.HeaderAnalysis) (int, rune) { func (h *HeaderAnalyzer) CalculateHeaderScore(analysis *model.HeaderAnalysis) (int, rune) {
if analysis == nil || analysis.Headers == nil { if analysis == nil || analysis.Headers == nil {
return 0, ' ' return 0, ' '
} }
@ -187,7 +188,7 @@ func (h *HeaderAnalyzer) parseEmailDate(dateStr string) (time.Time, error) {
} }
// isNoReplyAddress checks if a header check represents a no-reply email address // isNoReplyAddress checks if a header check represents a no-reply email address
func (h *HeaderAnalyzer) isNoReplyAddress(headerCheck api.HeaderCheck) bool { func (h *HeaderAnalyzer) isNoReplyAddress(headerCheck model.HeaderCheck) bool {
if !headerCheck.Present || headerCheck.Value == nil { if !headerCheck.Present || headerCheck.Value == nil {
return false return false
} }
@ -243,18 +244,18 @@ func (h *HeaderAnalyzer) formatAddress(addr *mail.Address) string {
} }
// GenerateHeaderAnalysis creates structured header analysis from email // GenerateHeaderAnalysis creates structured header analysis from email
func (h *HeaderAnalyzer) GenerateHeaderAnalysis(email *EmailMessage, authResults *api.AuthenticationResults) *api.HeaderAnalysis { func (h *HeaderAnalyzer) GenerateHeaderAnalysis(email *EmailMessage, authResults *model.AuthenticationResults) *model.HeaderAnalysis {
if email == nil { if email == nil {
return nil return nil
} }
analysis := &api.HeaderAnalysis{} analysis := &model.HeaderAnalysis{}
// Check for proper MIME structure // Check for proper MIME structure
analysis.HasMimeStructure = api.PtrTo(len(email.Parts) > 0) analysis.HasMimeStructure = utils.PtrTo(len(email.Parts) > 0)
// Initialize headers map // Initialize headers map
headers := make(map[string]api.HeaderCheck) headers := make(map[string]model.HeaderCheck)
// Check required headers // Check required headers
requiredHeaders := []string{"From", "To", "Date", "Message-ID", "Subject"} requiredHeaders := []string{"From", "To", "Date", "Message-ID", "Subject"}
@ -308,12 +309,12 @@ func (h *HeaderAnalyzer) GenerateHeaderAnalysis(email *EmailMessage, authResults
} }
// checkHeader checks if a header is present and valid // checkHeader checks if a header is present and valid
func (h *HeaderAnalyzer) checkHeader(email *EmailMessage, headerName string, importance string) *api.HeaderCheck { func (h *HeaderAnalyzer) checkHeader(email *EmailMessage, headerName string, importance string) *model.HeaderCheck {
value := email.GetHeaderValue(headerName) value := email.GetHeaderValue(headerName)
present := email.HasHeader(headerName) && value != "" present := email.HasHeader(headerName) && value != ""
importanceEnum := api.HeaderCheckImportance(importance) importanceEnum := model.HeaderCheckImportance(importance)
check := &api.HeaderCheck{ check := &model.HeaderCheck{
Present: present, Present: present,
Importance: &importanceEnum, Importance: &importanceEnum,
} }
@ -374,10 +375,10 @@ func (h *HeaderAnalyzer) checkHeader(email *EmailMessage, headerName string, imp
} }
// analyzeDomainAlignment checks domain alignment between headers and DKIM signatures // analyzeDomainAlignment checks domain alignment between headers and DKIM signatures
func (h *HeaderAnalyzer) analyzeDomainAlignment(email *EmailMessage, authResults *api.AuthenticationResults) *api.DomainAlignment { func (h *HeaderAnalyzer) analyzeDomainAlignment(email *EmailMessage, authResults *model.AuthenticationResults) *model.DomainAlignment {
alignment := &api.DomainAlignment{ alignment := &model.DomainAlignment{
Aligned: api.PtrTo(true), Aligned: utils.PtrTo(true),
RelaxedAligned: api.PtrTo(true), RelaxedAligned: utils.PtrTo(true),
} }
// Extract From domain // Extract From domain
@ -405,13 +406,13 @@ func (h *HeaderAnalyzer) analyzeDomainAlignment(email *EmailMessage, authResults
} }
// Extract DKIM domains from authentication results // Extract DKIM domains from authentication results
var dkimDomains []api.DKIMDomainInfo var dkimDomains []model.DKIMDomainInfo
if authResults != nil && authResults.Dkim != nil { if authResults != nil && authResults.Dkim != nil {
for _, dkim := range *authResults.Dkim { for _, dkim := range *authResults.Dkim {
if dkim.Domain != nil && *dkim.Domain != "" { if dkim.Domain != nil && *dkim.Domain != "" {
domain := *dkim.Domain domain := *dkim.Domain
orgDomain := h.getOrganizationalDomain(domain) orgDomain := h.getOrganizationalDomain(domain)
dkimDomains = append(dkimDomains, api.DKIMDomainInfo{ dkimDomains = append(dkimDomains, model.DKIMDomainInfo{
Domain: domain, Domain: domain,
OrgDomain: orgDomain, OrgDomain: orgDomain,
}) })
@ -560,18 +561,18 @@ func (h *HeaderAnalyzer) getOrganizationalDomain(domain string) string {
} }
// findHeaderIssues identifies issues with headers // findHeaderIssues identifies issues with headers
func (h *HeaderAnalyzer) findHeaderIssues(email *EmailMessage) []api.HeaderIssue { func (h *HeaderAnalyzer) findHeaderIssues(email *EmailMessage) []model.HeaderIssue {
var issues []api.HeaderIssue var issues []model.HeaderIssue
// Check for missing required headers // Check for missing required headers
requiredHeaders := []string{"From", "Date", "Message-ID"} requiredHeaders := []string{"From", "Date", "Message-ID"}
for _, header := range requiredHeaders { for _, header := range requiredHeaders {
if !email.HasHeader(header) || email.GetHeaderValue(header) == "" { if !email.HasHeader(header) || email.GetHeaderValue(header) == "" {
issues = append(issues, api.HeaderIssue{ issues = append(issues, model.HeaderIssue{
Header: header, Header: header,
Severity: api.HeaderIssueSeverityCritical, Severity: model.HeaderIssueSeverityCritical,
Message: fmt.Sprintf("Required header '%s' is missing", header), Message: fmt.Sprintf("Required header '%s' is missing", header),
Advice: api.PtrTo(fmt.Sprintf("Add the %s header to ensure RFC 5322 compliance", header)), Advice: utils.PtrTo(fmt.Sprintf("Add the %s header to ensure RFC 5322 compliance", header)),
}) })
} }
} }
@ -579,11 +580,11 @@ func (h *HeaderAnalyzer) findHeaderIssues(email *EmailMessage) []api.HeaderIssue
// Check Message-ID format // Check Message-ID format
messageID := email.GetHeaderValue("Message-ID") messageID := email.GetHeaderValue("Message-ID")
if messageID != "" && !h.isValidMessageID(messageID) { if messageID != "" && !h.isValidMessageID(messageID) {
issues = append(issues, api.HeaderIssue{ issues = append(issues, model.HeaderIssue{
Header: "Message-ID", Header: "Message-ID",
Severity: api.HeaderIssueSeverityMedium, Severity: model.HeaderIssueSeverityMedium,
Message: "Message-ID format is invalid", Message: "Message-ID format is invalid",
Advice: api.PtrTo("Use proper Message-ID format: <unique-id@domain.com>"), Advice: utils.PtrTo("Use proper Message-ID format: <unique-id@domain.com>"),
}) })
} }
@ -591,7 +592,7 @@ func (h *HeaderAnalyzer) findHeaderIssues(email *EmailMessage) []api.HeaderIssue
} }
// parseReceivedChain extracts the chain of Received headers from an email // parseReceivedChain extracts the chain of Received headers from an email
func (h *HeaderAnalyzer) parseReceivedChain(email *EmailMessage) []api.ReceivedHop { func (h *HeaderAnalyzer) parseReceivedChain(email *EmailMessage) []model.ReceivedHop {
if email == nil || email.Header == nil { if email == nil || email.Header == nil {
return nil return nil
} }
@ -601,7 +602,7 @@ func (h *HeaderAnalyzer) parseReceivedChain(email *EmailMessage) []api.ReceivedH
return nil return nil
} }
var chain []api.ReceivedHop var chain []model.ReceivedHop
for _, receivedValue := range receivedHeaders { for _, receivedValue := range receivedHeaders {
hop := h.parseReceivedHeader(receivedValue) hop := h.parseReceivedHeader(receivedValue)
@ -614,8 +615,8 @@ func (h *HeaderAnalyzer) parseReceivedChain(email *EmailMessage) []api.ReceivedH
} }
// parseReceivedHeader parses a single Received header value // parseReceivedHeader parses a single Received header value
func (h *HeaderAnalyzer) parseReceivedHeader(receivedValue string) *api.ReceivedHop { func (h *HeaderAnalyzer) parseReceivedHeader(receivedValue string) *model.ReceivedHop {
hop := &api.ReceivedHop{} hop := &model.ReceivedHop{}
// Normalize whitespace - Received headers can span multiple lines // Normalize whitespace - Received headers can span multiple lines
normalized := strings.Join(strings.Fields(receivedValue), " ") normalized := strings.Join(strings.Fields(receivedValue), " ")

24
pkg/analyzer/headers_test.go
View file

@ -27,7 +27,7 @@ import (
"strings" "strings"
"testing" "testing"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
func TestCalculateHeaderScore(t *testing.T) { func TestCalculateHeaderScore(t *testing.T) {
@ -404,7 +404,7 @@ func TestParseReceivedChain(t *testing.T) {
name string name string
receivedHeaders []string receivedHeaders []string
expectedHops int expectedHops int
validateFirst func(*testing.T, *EmailMessage, []api.ReceivedHop) validateFirst func(*testing.T, *EmailMessage, []model.ReceivedHop)
}{ }{
{ {
name: "No Received headers", name: "No Received headers",
@ -417,7 +417,7 @@ func TestParseReceivedChain(t *testing.T) {
"from mail.example.com (mail.example.com [192.0.2.1]) by mx.receiver.com (Postfix) with ESMTPS id ABC123 for <user@receiver.com>; Mon, 01 Jan 2024 12:00:00 +0000", "from mail.example.com (mail.example.com [192.0.2.1]) by mx.receiver.com (Postfix) with ESMTPS id ABC123 for <user@receiver.com>; Mon, 01 Jan 2024 12:00:00 +0000",
}, },
expectedHops: 1, expectedHops: 1,
validateFirst: func(t *testing.T, email *EmailMessage, hops []api.ReceivedHop) { validateFirst: func(t *testing.T, email *EmailMessage, hops []model.ReceivedHop) {
if len(hops) == 0 { if len(hops) == 0 {
t.Fatal("Expected at least one hop") t.Fatal("Expected at least one hop")
} }
@ -450,7 +450,7 @@ func TestParseReceivedChain(t *testing.T) {
"from mail2.example.com (mail2.example.com [192.0.2.2]) by mx2.receiver.com with SMTP id 222; Mon, 01 Jan 2024 11:59:00 +0000", "from mail2.example.com (mail2.example.com [192.0.2.2]) by mx2.receiver.com with SMTP id 222; Mon, 01 Jan 2024 11:59:00 +0000",
}, },
expectedHops: 2, expectedHops: 2,
validateFirst: func(t *testing.T, email *EmailMessage, hops []api.ReceivedHop) { validateFirst: func(t *testing.T, email *EmailMessage, hops []model.ReceivedHop) {
if len(hops) != 2 { if len(hops) != 2 {
t.Fatalf("Expected 2 hops, got %d", len(hops)) t.Fatalf("Expected 2 hops, got %d", len(hops))
} }
@ -472,7 +472,7 @@ func TestParseReceivedChain(t *testing.T) {
"from mail.example.com (unknown [IPv6:2607:5300:203:2818::1]) by mx.receiver.com with ESMTPS; Sun, 19 Oct 2025 09:40:33 +0000 (UTC)", "from mail.example.com (unknown [IPv6:2607:5300:203:2818::1]) by mx.receiver.com with ESMTPS; Sun, 19 Oct 2025 09:40:33 +0000 (UTC)",
}, },
expectedHops: 1, expectedHops: 1,
validateFirst: func(t *testing.T, email *EmailMessage, hops []api.ReceivedHop) { validateFirst: func(t *testing.T, email *EmailMessage, hops []model.ReceivedHop) {
if len(hops) == 0 { if len(hops) == 0 {
t.Fatal("Expected at least one hop") t.Fatal("Expected at least one hop")
} }
@ -499,7 +499,7 @@ func TestParseReceivedChain(t *testing.T) {
for <test-9a9ce364-c394-4fa9-acef-d46ff2f482bf@deliver.happydomain.org>; Sun, 19 Oct 2025 09:40:33 +0000 (UTC)`, for <test-9a9ce364-c394-4fa9-acef-d46ff2f482bf@deliver.happydomain.org>; Sun, 19 Oct 2025 09:40:33 +0000 (UTC)`,
}, },
expectedHops: 1, expectedHops: 1,
validateFirst: func(t *testing.T, email *EmailMessage, hops []api.ReceivedHop) { validateFirst: func(t *testing.T, email *EmailMessage, hops []model.ReceivedHop) {
if len(hops) == 0 { if len(hops) == 0 {
t.Fatal("Expected at least one hop") t.Fatal("Expected at least one hop")
} }
@ -527,7 +527,7 @@ func TestParseReceivedChain(t *testing.T) {
"from unknown by localhost", "from unknown by localhost",
}, },
expectedHops: 1, expectedHops: 1,
validateFirst: func(t *testing.T, email *EmailMessage, hops []api.ReceivedHop) { validateFirst: func(t *testing.T, email *EmailMessage, hops []model.ReceivedHop) {
if len(hops) == 0 { if len(hops) == 0 {
t.Fatal("Expected at least one hop") t.Fatal("Expected at least one hop")
} }
@ -1012,16 +1012,16 @@ func TestAnalyzeDomainAlignment_WithDKIM(t *testing.T) {
} }
// Create authentication results with DKIM signatures // Create authentication results with DKIM signatures
var authResults *api.AuthenticationResults var authResults *model.AuthenticationResults
if len(tt.dkimDomains) > 0 { if len(tt.dkimDomains) > 0 {
dkimResults := make([]api.AuthResult, 0, len(tt.dkimDomains)) dkimResults := make([]model.AuthResult, 0, len(tt.dkimDomains))
for _, domain := range tt.dkimDomains { for _, domain := range tt.dkimDomains {
dkimResults = append(dkimResults, api.AuthResult{ dkimResults = append(dkimResults, model.AuthResult{
Result: api.AuthResultResultPass, Result: model.AuthResultResultPass,
Domain: &domain, Domain: &domain,
}) })
} }
authResults = &api.AuthenticationResults{ authResults = &model.AuthenticationResults{
Dkim: &dkimResults, Dkim: &dkimResults,
} }
} }

15
pkg/analyzer/parser.go
View file

@ -28,16 +28,9 @@ import (
"mime/multipart" "mime/multipart"
"net/mail" "net/mail"
"net/textproto" "net/textproto"
"os"
"strings" "strings"
) )
var hostname = ""
func init() {
hostname, _ = os.Hostname()
}
// EmailMessage represents a parsed email message // EmailMessage represents a parsed email message
type EmailMessage struct { type EmailMessage struct {
Header mail.Header Header mail.Header
@ -218,18 +211,18 @@ func buildRawHeaders(header mail.Header) string {
} }
// GetAuthenticationResults extracts Authentication-Results headers // GetAuthenticationResults extracts Authentication-Results headers
// If hostname is provided, only returns headers that begin with that hostname // If receiverHostname is provided, only returns headers that begin with that hostname
func (e *EmailMessage) GetAuthenticationResults() []string { func (e *EmailMessage) GetAuthenticationResults(receiverHostname string) []string {
allResults := e.Header[textproto.CanonicalMIMEHeaderKey("Authentication-Results")] allResults := e.Header[textproto.CanonicalMIMEHeaderKey("Authentication-Results")]
// If no hostname specified, return all results // If no hostname specified, return all results
if hostname == "" { if receiverHostname == "" {
return allResults return allResults
} }
// Filter results that begin with the specified hostname // Filter results that begin with the specified hostname
var filtered []string var filtered []string
prefix := hostname + ";" prefix := receiverHostname + ";"
for _, result := range allResults { for _, result := range allResults {
// Trim whitespace and check if it starts with hostname; // Trim whitespace and check if it starts with hostname;
trimmed := strings.TrimSpace(result) trimmed := strings.TrimSpace(result)

5
pkg/analyzer/parser_test.go
View file

@ -106,9 +106,6 @@ Content-Type: text/html; charset=utf-8
} }
func TestGetAuthenticationResults(t *testing.T) { func TestGetAuthenticationResults(t *testing.T) {
// Force hostname
hostname = "example.com"
rawEmail := `From: sender@example.com rawEmail := `From: sender@example.com
To: recipient@example.com To: recipient@example.com
Subject: Test Email Subject: Test Email
@ -123,7 +120,7 @@ Body content.
t.Fatalf("Failed to parse email: %v", err) t.Fatalf("Failed to parse email: %v", err)
} }
authResults := email.GetAuthenticationResults() authResults := email.GetAuthenticationResults("example.com")
if len(authResults) != 2 { if len(authResults) != 2 {
t.Errorf("Expected 2 Authentication-Results headers, got: %d", len(authResults)) t.Errorf("Expected 2 Authentication-Results headers, got: %d", len(authResults))
} }

40
pkg/analyzer/rbl.go
View file

@ -30,7 +30,8 @@ import (
"sync" "sync"
"time" "time"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// DNSListChecker checks IP addresses against DNS-based block/allow lists. // DNSListChecker checks IP addresses against DNS-based block/allow lists.
@ -117,7 +118,7 @@ func NewDNSWLChecker(timeout time.Duration, dnswls []string, checkAllIPs bool) *
// DNSListResults represents the results of DNS list checks // DNSListResults represents the results of DNS list checks
type DNSListResults struct { type DNSListResults struct {
Checks map[string][]api.BlacklistCheck // Map of IP -> list of checks for that IP Checks map[string][]model.BlacklistCheck // Map of IP -> list of checks for that IP
IPsChecked []string IPsChecked []string
ListedCount int // Total listings including informational entries ListedCount int // Total listings including informational entries
RelevantListedCount int // Listings on scoring (non-informational) lists only RelevantListedCount int // Listings on scoring (non-informational) lists only
@ -126,7 +127,7 @@ type DNSListResults struct {
// CheckEmail checks all IPs found in the email headers against the configured lists // CheckEmail checks all IPs found in the email headers against the configured lists
func (r *DNSListChecker) CheckEmail(email *EmailMessage) *DNSListResults { func (r *DNSListChecker) CheckEmail(email *EmailMessage) *DNSListResults {
results := &DNSListResults{ results := &DNSListResults{
Checks: make(map[string][]api.BlacklistCheck), Checks: make(map[string][]model.BlacklistCheck),
} }
ips := r.extractIPs(email) ips := r.extractIPs(email)
@ -157,12 +158,12 @@ func (r *DNSListChecker) CheckEmail(email *EmailMessage) *DNSListResults {
} }
// CheckIP checks a single IP address against all configured lists in parallel // CheckIP checks a single IP address against all configured lists in parallel
func (r *DNSListChecker) CheckIP(ip string) ([]api.BlacklistCheck, int, error) { func (r *DNSListChecker) CheckIP(ip string) ([]model.BlacklistCheck, int, error) {
if !r.isPublicIP(ip) { if !r.isPublicIP(ip) {
return nil, 0, fmt.Errorf("invalid or non-public IP address: %s", ip) return nil, 0, fmt.Errorf("invalid or non-public IP address: %s", ip)
} }
checks := make([]api.BlacklistCheck, len(r.Lists)) checks := make([]model.BlacklistCheck, len(r.Lists))
var wg sync.WaitGroup var wg sync.WaitGroup
for i, list := range r.Lists { for i, list := range r.Lists {
@ -239,14 +240,14 @@ func (r *DNSListChecker) isPublicIP(ipStr string) bool {
} }
// checkIP checks a single IP against a single DNS list // checkIP checks a single IP against a single DNS list
func (r *DNSListChecker) checkIP(ip, list string) api.BlacklistCheck { func (r *DNSListChecker) checkIP(ip, list string) model.BlacklistCheck {
check := api.BlacklistCheck{ check := model.BlacklistCheck{
Rbl: list, Rbl: list,
} }
reversedIP := r.reverseIP(ip) reversedIP := r.reverseIP(ip)
if reversedIP == "" { if reversedIP == "" {
check.Error = api.PtrTo("Failed to reverse IP address") check.Error = utils.PtrTo("Failed to reverse IP address")
return check return check
} }
@ -263,17 +264,17 @@ func (r *DNSListChecker) checkIP(ip, list string) api.BlacklistCheck {
return check return check
} }
} }
check.Error = api.PtrTo(fmt.Sprintf("DNS lookup failed: %v", err)) check.Error = utils.PtrTo(fmt.Sprintf("DNS lookup failed: %v", err))
return check return check
} }
if len(addrs) > 0 { if len(addrs) > 0 {
check.Response = api.PtrTo(addrs[0]) check.Response = utils.PtrTo(addrs[0])
// In RBL mode, 127.255.255.253/254/255 indicate operational errors, not real listings. // In RBL mode, 127.255.255.253/254/255 indicate operational errors, not real listings.
if r.filterErrorCodes && (addrs[0] == "127.255.255.253" || addrs[0] == "127.255.255.254" || addrs[0] == "127.255.255.255") { if r.filterErrorCodes && (addrs[0] == "127.255.255.253" || addrs[0] == "127.255.255.254" || addrs[0] == "127.255.255.255") {
check.Listed = false check.Listed = false
check.Error = api.PtrTo(fmt.Sprintf("RBL %s returned error code %s (RBL operational issue)", list, addrs[0])) check.Error = utils.PtrTo(fmt.Sprintf("RBL %s returned error code %s (RBL operational issue)", list, addrs[0]))
} else { } else {
check.Listed = true check.Listed = true
} }
@ -300,13 +301,24 @@ func (r *DNSListChecker) reverseIP(ipStr string) string {
// CalculateScore calculates the list contribution to deliverability. // CalculateScore calculates the list contribution to deliverability.
// Informational lists are not counted in the score. // Informational lists are not counted in the score.
func (r *DNSListChecker) CalculateScore(results *DNSListResults) (int, string) { func (r *DNSListChecker) CalculateScore(results *DNSListResults, forWhitelist bool) (int, string) {
scoringListCount := len(r.Lists) - len(r.informationalSet)
if forWhitelist {
if results.ListedCount >= scoringListCount {
return 100, "A++"
} else if results.ListedCount > 0 {
return 100, "A+"
} else {
return 95, "A"
}
}
if results == nil || len(results.IPsChecked) == 0 { if results == nil || len(results.IPsChecked) == 0 {
return 100, "" return 100, ""
} }
scoringListCount := len(r.Lists) - len(r.informationalSet) if results.ListedCount <= 0 {
if scoringListCount <= 0 {
return 100, "A+" return 100, "A+"
} }

6
pkg/analyzer/rbl_test.go
View file

@ -26,7 +26,7 @@ import (
"testing" "testing"
"time" "time"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
func TestNewRBLChecker(t *testing.T) { func TestNewRBLChecker(t *testing.T) {
@ -336,7 +336,7 @@ func TestGetBlacklistScore(t *testing.T) {
func TestGetUniqueListedIPs(t *testing.T) { func TestGetUniqueListedIPs(t *testing.T) {
results := &DNSListResults{ results := &DNSListResults{
Checks: map[string][]api.BlacklistCheck{ Checks: map[string][]model.BlacklistCheck{
"198.51.100.1": { "198.51.100.1": {
{Rbl: "zen.spamhaus.org", Listed: true}, {Rbl: "zen.spamhaus.org", Listed: true},
{Rbl: "bl.spamcop.net", Listed: true}, {Rbl: "bl.spamcop.net", Listed: true},
@ -364,7 +364,7 @@ func TestGetUniqueListedIPs(t *testing.T) {
func TestGetRBLsForIP(t *testing.T) { func TestGetRBLsForIP(t *testing.T) {
results := &DNSListResults{ results := &DNSListResults{
Checks: map[string][]api.BlacklistCheck{ Checks: map[string][]model.BlacklistCheck{
"198.51.100.1": { "198.51.100.1": {
{Rbl: "zen.spamhaus.org", Listed: true}, {Rbl: "zen.spamhaus.org", Listed: true},
{Rbl: "bl.spamcop.net", Listed: true}, {Rbl: "bl.spamcop.net", Listed: true},

52
pkg/analyzer/report.go
View file

@ -24,7 +24,7 @@ package analyzer
import ( import (
"time" "time"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils" "git.happydns.org/happyDeliver/internal/utils"
"github.com/google/uuid" "github.com/google/uuid"
) )
@ -43,16 +43,18 @@ type ReportGenerator struct {
// NewReportGenerator creates a new report generator // NewReportGenerator creates a new report generator
func NewReportGenerator( func NewReportGenerator(
receiverHostname string,
dnsTimeout time.Duration, dnsTimeout time.Duration,
httpTimeout time.Duration, httpTimeout time.Duration,
rbls []string, rbls []string,
dnswls []string, dnswls []string,
checkAllIPs bool, checkAllIPs bool,
rspamdAPIURL string,
) *ReportGenerator { ) *ReportGenerator {
return &ReportGenerator{ return &ReportGenerator{
authAnalyzer: NewAuthenticationAnalyzer(), authAnalyzer: NewAuthenticationAnalyzer(receiverHostname),
spamAnalyzer: NewSpamAssassinAnalyzer(), spamAnalyzer: NewSpamAssassinAnalyzer(),
rspamdAnalyzer: NewRspamdAnalyzer(), rspamdAnalyzer: NewRspamdAnalyzer(LoadRspamdSymbols(rspamdAPIURL)),
dnsAnalyzer: NewDNSAnalyzer(dnsTimeout), dnsAnalyzer: NewDNSAnalyzer(dnsTimeout),
rblChecker: NewRBLChecker(dnsTimeout, rbls, checkAllIPs), rblChecker: NewRBLChecker(dnsTimeout, rbls, checkAllIPs),
dnswlChecker: NewDNSWLChecker(dnsTimeout, dnswls, checkAllIPs), dnswlChecker: NewDNSWLChecker(dnsTimeout, dnswls, checkAllIPs),
@ -64,14 +66,14 @@ func NewReportGenerator(
// AnalysisResults contains all intermediate analysis results // AnalysisResults contains all intermediate analysis results
type AnalysisResults struct { type AnalysisResults struct {
Email *EmailMessage Email *EmailMessage
Authentication *api.AuthenticationResults Authentication *model.AuthenticationResults
Content *ContentResults Content *ContentResults
DNS *api.DNSResults DNS *model.DNSResults
Headers *api.HeaderAnalysis Headers *model.HeaderAnalysis
RBL *DNSListResults RBL *DNSListResults
DNSWL *DNSListResults DNSWL *DNSListResults
SpamAssassin *api.SpamAssassinResult SpamAssassin *model.SpamAssassinResult
Rspamd *api.RspamdResult Rspamd *model.RspamdResult
} }
// AnalyzeEmail performs complete email analysis // AnalyzeEmail performs complete email analysis
@ -83,7 +85,7 @@ func (r *ReportGenerator) AnalyzeEmail(email *EmailMessage) *AnalysisResults {
// Run all analyzers // Run all analyzers
results.Authentication = r.authAnalyzer.AnalyzeAuthentication(email) results.Authentication = r.authAnalyzer.AnalyzeAuthentication(email)
results.Headers = r.headerAnalyzer.GenerateHeaderAnalysis(email, results.Authentication) results.Headers = r.headerAnalyzer.GenerateHeaderAnalysis(email, results.Authentication)
results.DNS = r.dnsAnalyzer.AnalyzeDNS(email, results.Authentication, results.Headers) results.DNS = r.dnsAnalyzer.AnalyzeDNS(email, results.Headers)
results.RBL = r.rblChecker.CheckEmail(email) results.RBL = r.rblChecker.CheckEmail(email)
results.DNSWL = r.dnswlChecker.CheckEmail(email) results.DNSWL = r.dnswlChecker.CheckEmail(email)
results.SpamAssassin = r.spamAnalyzer.AnalyzeSpamAssassin(email) results.SpamAssassin = r.spamAnalyzer.AnalyzeSpamAssassin(email)
@ -94,11 +96,11 @@ func (r *ReportGenerator) AnalyzeEmail(email *EmailMessage) *AnalysisResults {
} }
// GenerateReport creates a complete API report from analysis results // GenerateReport creates a complete API report from analysis results
func (r *ReportGenerator) GenerateReport(testID uuid.UUID, results *AnalysisResults) *api.Report { func (r *ReportGenerator) GenerateReport(testID uuid.UUID, results *AnalysisResults) *model.Report {
reportID := uuid.New() reportID := uuid.New()
now := time.Now() now := time.Now()
report := &api.Report{ report := &model.Report{
Id: utils.UUIDToBase32(reportID), Id: utils.UUIDToBase32(reportID),
TestId: utils.UUIDToBase32(testID), TestId: utils.UUIDToBase32(testID),
CreatedAt: now, CreatedAt: now,
@ -139,8 +141,10 @@ func (r *ReportGenerator) GenerateReport(testID uuid.UUID, results *AnalysisResu
blacklistScore := 0 blacklistScore := 0
var blacklistGrade string var blacklistGrade string
var whitelistGrade string
if results.RBL != nil { if results.RBL != nil {
blacklistScore, blacklistGrade = r.rblChecker.CalculateScore(results.RBL) blacklistScore, blacklistGrade = r.rblChecker.CalculateScore(results.RBL, false)
_, whitelistGrade = r.dnswlChecker.CalculateScore(results.DNSWL, true)
} }
saScore, saGrade := r.spamAnalyzer.CalculateSpamAssassinScore(results.SpamAssassin) saScore, saGrade := r.spamAnalyzer.CalculateSpamAssassinScore(results.SpamAssassin)
@ -165,19 +169,19 @@ func (r *ReportGenerator) GenerateReport(testID uuid.UUID, results *AnalysisResu
spamGrade = MinGrade(saGrade, rspamdGrade) spamGrade = MinGrade(saGrade, rspamdGrade)
} }
report.Summary = &api.ScoreSummary{ report.Summary = &model.ScoreSummary{
DnsScore: dnsScore, DnsScore: dnsScore,
DnsGrade: api.ScoreSummaryDnsGrade(dnsGrade), DnsGrade: model.ScoreSummaryDnsGrade(dnsGrade),
AuthenticationScore: authScore, AuthenticationScore: authScore,
AuthenticationGrade: api.ScoreSummaryAuthenticationGrade(authGrade), AuthenticationGrade: model.ScoreSummaryAuthenticationGrade(authGrade),
BlacklistScore: blacklistScore, BlacklistScore: blacklistScore,
BlacklistGrade: api.ScoreSummaryBlacklistGrade(blacklistGrade), BlacklistGrade: model.ScoreSummaryBlacklistGrade(MinGrade(blacklistGrade, whitelistGrade)),
ContentScore: contentScore, ContentScore: contentScore,
ContentGrade: api.ScoreSummaryContentGrade(contentGrade), ContentGrade: model.ScoreSummaryContentGrade(contentGrade),
HeaderScore: headerScore, HeaderScore: headerScore,
HeaderGrade: api.ScoreSummaryHeaderGrade(headerGrade), HeaderGrade: model.ScoreSummaryHeaderGrade(headerGrade),
SpamScore: spamScore, SpamScore: spamScore,
SpamGrade: api.ScoreSummarySpamGrade(spamGrade), SpamGrade: model.ScoreSummarySpamGrade(spamGrade),
} }
// Add authentication results // Add authentication results
@ -209,16 +213,16 @@ func (r *ReportGenerator) GenerateReport(testID uuid.UUID, results *AnalysisResu
// Add SpamAssassin result with individual deliverability score // Add SpamAssassin result with individual deliverability score
if results.SpamAssassin != nil { if results.SpamAssassin != nil {
saGradeTyped := api.SpamAssassinResultDeliverabilityGrade(saGrade) saGradeTyped := model.SpamAssassinResultDeliverabilityGrade(saGrade)
results.SpamAssassin.DeliverabilityScore = api.PtrTo(saScore) results.SpamAssassin.DeliverabilityScore = utils.PtrTo(saScore)
results.SpamAssassin.DeliverabilityGrade = &saGradeTyped results.SpamAssassin.DeliverabilityGrade = &saGradeTyped
} }
report.Spamassassin = results.SpamAssassin report.Spamassassin = results.SpamAssassin
// Add rspamd result with individual deliverability score // Add rspamd result with individual deliverability score
if results.Rspamd != nil { if results.Rspamd != nil {
rspamdGradeTyped := api.RspamdResultDeliverabilityGrade(rspamdGrade) rspamdGradeTyped := model.RspamdResultDeliverabilityGrade(rspamdGrade)
results.Rspamd.DeliverabilityScore = api.PtrTo(rspamdScore) results.Rspamd.DeliverabilityScore = utils.PtrTo(rspamdScore)
results.Rspamd.DeliverabilityGrade = &rspamdGradeTyped results.Rspamd.DeliverabilityGrade = &rspamdGradeTyped
} }
report.Rspamd = results.Rspamd report.Rspamd = results.Rspamd
@ -284,7 +288,7 @@ func (r *ReportGenerator) GenerateReport(testID uuid.UUID, results *AnalysisResu
} }
if minusGrade < 255 { if minusGrade < 255 {
report.Grade = api.ReportGrade(string([]byte{'A' + minusGrade})) report.Grade = model.ReportGrade(string([]byte{'A' + minusGrade}))
} }
} }

10
pkg/analyzer/report_test.go
View file

@ -32,7 +32,7 @@ import (
) )
func TestNewReportGenerator(t *testing.T) { func TestNewReportGenerator(t *testing.T) {
gen := NewReportGenerator(10*time.Second, 10*time.Second, DefaultRBLs, DefaultDNSWLs, false) gen := NewReportGenerator("", 10*time.Second, 10*time.Second, DefaultRBLs, DefaultDNSWLs, false, "")
if gen == nil { if gen == nil {
t.Fatal("Expected report generator, got nil") t.Fatal("Expected report generator, got nil")
} }
@ -55,7 +55,7 @@ func TestNewReportGenerator(t *testing.T) {
} }
func TestAnalyzeEmail(t *testing.T) { func TestAnalyzeEmail(t *testing.T) {
gen := NewReportGenerator(10*time.Second, 10*time.Second, DefaultRBLs, DefaultDNSWLs, false) gen := NewReportGenerator("", 10*time.Second, 10*time.Second, DefaultRBLs, DefaultDNSWLs, false, "")
email := createTestEmail() email := createTestEmail()
@ -75,7 +75,7 @@ func TestAnalyzeEmail(t *testing.T) {
} }
func TestGenerateReport(t *testing.T) { func TestGenerateReport(t *testing.T) {
gen := NewReportGenerator(10*time.Second, 10*time.Second, DefaultRBLs, DefaultDNSWLs, false) gen := NewReportGenerator("", 10*time.Second, 10*time.Second, DefaultRBLs, DefaultDNSWLs, false, "")
testID := uuid.New() testID := uuid.New()
email := createTestEmail() email := createTestEmail()
@ -130,7 +130,7 @@ func TestGenerateReport(t *testing.T) {
} }
func TestGenerateReportWithSpamAssassin(t *testing.T) { func TestGenerateReportWithSpamAssassin(t *testing.T) {
gen := NewReportGenerator(10*time.Second, 10*time.Second, DefaultRBLs, DefaultDNSWLs, false) gen := NewReportGenerator("", 10*time.Second, 10*time.Second, DefaultRBLs, DefaultDNSWLs, false, "")
testID := uuid.New() testID := uuid.New()
email := createTestEmailWithSpamAssassin() email := createTestEmailWithSpamAssassin()
@ -150,7 +150,7 @@ func TestGenerateReportWithSpamAssassin(t *testing.T) {
} }
func TestGenerateRawEmail(t *testing.T) { func TestGenerateRawEmail(t *testing.T) {
gen := NewReportGenerator(10*time.Second, 10*time.Second, DefaultRBLs, DefaultDNSWLs, false) gen := NewReportGenerator("", 10*time.Second, 10*time.Second, DefaultRBLs, DefaultDNSWLs, false, "")
tests := []struct { tests := []struct {
name string name string

21
pkg/analyzer/rspamd-symbols-README.md Normal file
View file

@ -0,0 +1,21 @@
# rspamd-symbols.json
This file contains rspamd symbol descriptions, embedded into the binary at compile time as a fallback when no rspamd API URL is configured.
## How to update
Fetch the latest symbols from a running rspamd instance:
```sh
curl http://127.0.0.1:11334/symbols > rspamd-symbols.json
```
Or with docker:
```sh
docker run --rm --name rspamd --pull always rspamd/rspamd
docker exec -u 0 rspamd apt install -y curl
docker exec rspamd curl http://127.0.0.1:11334/symbols > rspamd-symbols.json
```
Then rebuild the project.

6646
pkg/analyzer/rspamd-symbols.json Normal file
View file

File diff suppressed because it is too large Load diff

41
pkg/analyzer/rspamd.go
View file

@ -27,7 +27,7 @@ import (
"strconv" "strconv"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
// Default rspamd action thresholds (rspamd built-in defaults) // Default rspamd action thresholds (rspamd built-in defaults)
@ -37,22 +37,31 @@ const (
) )
// RspamdAnalyzer analyzes rspamd results from email headers // RspamdAnalyzer analyzes rspamd results from email headers
type RspamdAnalyzer struct{} type RspamdAnalyzer struct {
symbols map[string]string
}
// NewRspamdAnalyzer creates a new rspamd analyzer // NewRspamdAnalyzer creates a new rspamd analyzer with optional symbol descriptions
func NewRspamdAnalyzer() *RspamdAnalyzer { func NewRspamdAnalyzer(symbols map[string]string) *RspamdAnalyzer {
return &RspamdAnalyzer{} return &RspamdAnalyzer{symbols: symbols}
} }
// AnalyzeRspamd extracts and analyzes rspamd results from email headers // AnalyzeRspamd extracts and analyzes rspamd results from email headers
func (a *RspamdAnalyzer) AnalyzeRspamd(email *EmailMessage) *api.RspamdResult { func (a *RspamdAnalyzer) AnalyzeRspamd(email *EmailMessage) *model.RspamdResult {
headers := email.GetRspamdHeaders() headers := email.GetRspamdHeaders()
if len(headers) == 0 { if len(headers) == 0 {
return nil return nil
} }
result := &api.RspamdResult{ // Require at least X-Spamd-Result or X-Rspamd-Score to produce a meaningful report
Symbols: make(map[string]api.RspamdSymbol), _, hasSpamdResult := headers["X-Spamd-Result"]
_, hasRspamdScore := headers["X-Rspamd-Score"]
if !hasSpamdResult && !hasRspamdScore {
return nil
}
result := &model.RspamdResult{
Symbols: make(map[string]model.SpamTestDetail),
} }
// Parse X-Spamd-Result header (primary source for score, threshold, and symbols) // Parse X-Spamd-Result header (primary source for score, threshold, and symbols)
@ -76,6 +85,16 @@ func (a *RspamdAnalyzer) AnalyzeRspamd(email *EmailMessage) *api.RspamdResult {
result.Server = &server result.Server = &server
} }
// Populate symbol descriptions from the lookup map
if a.symbols != nil {
for name, sym := range result.Symbols {
if desc, ok := a.symbols[name]; ok {
sym.Description = &desc
result.Symbols[name] = sym
}
}
}
// Derive IsSpam from score vs reject threshold. // Derive IsSpam from score vs reject threshold.
if result.Threshold > 0 { if result.Threshold > 0 {
result.IsSpam = result.Score >= result.Threshold result.IsSpam = result.Score >= result.Threshold
@ -88,7 +107,7 @@ func (a *RspamdAnalyzer) AnalyzeRspamd(email *EmailMessage) *api.RspamdResult {
// parseSpamdResult parses the X-Spamd-Result header // parseSpamdResult parses the X-Spamd-Result header
// Format: "default: False [-3.91 / 15.00];\n\tSYMBOL(score)[params]; ..." // Format: "default: False [-3.91 / 15.00];\n\tSYMBOL(score)[params]; ..."
func (a *RspamdAnalyzer) parseSpamdResult(header string, result *api.RspamdResult) { func (a *RspamdAnalyzer) parseSpamdResult(header string, result *model.RspamdResult) {
// Extract score and threshold from the first line // Extract score and threshold from the first line
// e.g. "default: False [-3.91 / 15.00]" // e.g. "default: False [-3.91 / 15.00]"
scoreRe := regexp.MustCompile(`\[\s*(-?\d+\.?\d*)\s*/\s*(-?\d+\.?\d*)\s*\]`) scoreRe := regexp.MustCompile(`\[\s*(-?\d+\.?\d*)\s*/\s*(-?\d+\.?\d*)\s*\]`)
@ -122,7 +141,7 @@ func (a *RspamdAnalyzer) parseSpamdResult(header string, result *api.RspamdResul
if len(matches) > 2 { if len(matches) > 2 {
name := matches[1] name := matches[1]
score, _ := strconv.ParseFloat(matches[2], 64) score, _ := strconv.ParseFloat(matches[2], 64)
sym := api.RspamdSymbol{ sym := model.SpamTestDetail{
Name: name, Name: name,
Score: float32(score), Score: float32(score),
} }
@ -136,7 +155,7 @@ func (a *RspamdAnalyzer) parseSpamdResult(header string, result *api.RspamdResul
} }
// CalculateRspamdScore calculates the rspamd contribution to deliverability (0-100 scale) // CalculateRspamdScore calculates the rspamd contribution to deliverability (0-100 scale)
func (a *RspamdAnalyzer) CalculateRspamdScore(result *api.RspamdResult) (int, string) { func (a *RspamdAnalyzer) CalculateRspamdScore(result *model.RspamdResult) (int, string) {
if result == nil { if result == nil {
return 100, "" // rspamd not installed return 100, "" // rspamd not installed
} }

105
pkg/analyzer/rspamd_symbols.go Normal file
View file

@ -0,0 +1,105 @@
// This file is part of the happyDeliver (R) project.
// Copyright (c) 2026 happyDomain
// Authors: Pierre-Olivier Mercier, et al.
//
// This program is offered under a commercial and under the AGPL license.
// For commercial licensing, contact us at <contact@happydomain.org>.
//
// For AGPL licensing:
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
package analyzer
import (
_ "embed"
"encoding/json"
"io"
"log"
"net/http"
"strings"
"time"
)
//go:embed rspamd-symbols.json
var embeddedRspamdSymbols []byte
// rspamdSymbolGroup represents a group of rspamd symbols from the API/embedded JSON.
type rspamdSymbolGroup struct {
Group string `json:"group"`
Rules []rspamdSymbolEntry `json:"rules"`
}
// rspamdSymbolEntry represents a single rspamd symbol entry.
type rspamdSymbolEntry struct {
Symbol string `json:"symbol"`
Description string `json:"description"`
Weight float64 `json:"weight"`
}
// parseRspamdSymbolsJSON parses the rspamd symbols JSON into a name->description map.
func parseRspamdSymbolsJSON(data []byte) map[string]string {
var groups []rspamdSymbolGroup
if err := json.Unmarshal(data, &groups); err != nil {
log.Printf("Failed to parse rspamd symbols JSON: %v", err)
return nil
}
symbols := make(map[string]string, len(groups)*10)
for _, g := range groups {
for _, r := range g.Rules {
if r.Description != "" {
symbols[r.Symbol] = r.Description
}
}
}
return symbols
}
// LoadRspamdSymbols loads rspamd symbol descriptions.
// If apiURL is non-empty, it fetches from the rspamd API first, falling back to the embedded list on error.
func LoadRspamdSymbols(apiURL string) map[string]string {
if apiURL != "" {
if symbols := fetchRspamdSymbols(apiURL); symbols != nil {
return symbols
}
log.Printf("Failed to fetch rspamd symbols from %s, using embedded list", apiURL)
}
return parseRspamdSymbolsJSON(embeddedRspamdSymbols)
}
// fetchRspamdSymbols fetches symbol descriptions from the rspamd API.
func fetchRspamdSymbols(apiURL string) map[string]string {
url := strings.TrimRight(apiURL, "/") + "/symbols"
client := &http.Client{Timeout: 10 * time.Second}
resp, err := client.Get(url)
if err != nil {
log.Printf("Error fetching rspamd symbols: %v", err)
return nil
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
log.Printf("rspamd API returned status %d", resp.StatusCode)
return nil
}
body, err := io.ReadAll(resp.Body)
if err != nil {
log.Printf("Error reading rspamd symbols response: %v", err)
return nil
}
return parseRspamdSymbolsJSON(body)
}

28
pkg/analyzer/rspamd_test.go
View file

@ -26,11 +26,11 @@ import (
"net/mail" "net/mail"
"testing" "testing"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
func TestAnalyzeRspamdNoHeaders(t *testing.T) { func TestAnalyzeRspamdNoHeaders(t *testing.T) {
analyzer := NewRspamdAnalyzer() analyzer := NewRspamdAnalyzer(nil)
email := &EmailMessage{Header: make(mail.Header)} email := &EmailMessage{Header: make(mail.Header)}
result := analyzer.AnalyzeRspamd(email) result := analyzer.AnalyzeRspamd(email)
@ -126,12 +126,12 @@ func TestParseSpamdResult(t *testing.T) {
}, },
} }
analyzer := NewRspamdAnalyzer() analyzer := NewRspamdAnalyzer(nil)
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
result := &api.RspamdResult{ result := &model.RspamdResult{
Symbols: make(map[string]api.RspamdSymbol), Symbols: make(map[string]model.SpamTestDetail),
} }
analyzer.parseSpamdResult(tt.header, result) analyzer.parseSpamdResult(tt.header, result)
@ -241,7 +241,7 @@ func TestAnalyzeRspamd(t *testing.T) {
}, },
} }
analyzer := NewRspamdAnalyzer() analyzer := NewRspamdAnalyzer(nil)
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
@ -281,7 +281,7 @@ func TestAnalyzeRspamd(t *testing.T) {
func TestCalculateRspamdScore(t *testing.T) { func TestCalculateRspamdScore(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
result *api.RspamdResult result *model.RspamdResult
expectedScore int expectedScore int
expectedGrade string expectedGrade string
}{ }{
@ -293,7 +293,7 @@ func TestCalculateRspamdScore(t *testing.T) {
}, },
{ {
name: "Score well below threshold", name: "Score well below threshold",
result: &api.RspamdResult{ result: &model.RspamdResult{
Score: -3.91, Score: -3.91,
Threshold: 15.00, Threshold: 15.00,
}, },
@ -302,7 +302,7 @@ func TestCalculateRspamdScore(t *testing.T) {
}, },
{ {
name: "Score at zero", name: "Score at zero",
result: &api.RspamdResult{ result: &model.RspamdResult{
Score: 0, Score: 0,
Threshold: 15.00, Threshold: 15.00,
}, },
@ -312,7 +312,7 @@ func TestCalculateRspamdScore(t *testing.T) {
}, },
{ {
name: "Score at threshold (half of 2*threshold)", name: "Score at threshold (half of 2*threshold)",
result: &api.RspamdResult{ result: &model.RspamdResult{
Score: 15.00, Score: 15.00,
Threshold: 15.00, Threshold: 15.00,
}, },
@ -321,7 +321,7 @@ func TestCalculateRspamdScore(t *testing.T) {
}, },
{ {
name: "Score above 2*threshold", name: "Score above 2*threshold",
result: &api.RspamdResult{ result: &model.RspamdResult{
Score: 31.00, Score: 31.00,
Threshold: 15.00, Threshold: 15.00,
}, },
@ -330,7 +330,7 @@ func TestCalculateRspamdScore(t *testing.T) {
}, },
{ {
name: "Score exactly at 2*threshold", name: "Score exactly at 2*threshold",
result: &api.RspamdResult{ result: &model.RspamdResult{
Score: 30.00, Score: 30.00,
Threshold: 15.00, Threshold: 15.00,
}, },
@ -340,7 +340,7 @@ func TestCalculateRspamdScore(t *testing.T) {
}, },
} }
analyzer := NewRspamdAnalyzer() analyzer := NewRspamdAnalyzer(nil)
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
@ -380,7 +380,7 @@ func TestAnalyzeRspamdRealEmail(t *testing.T) {
t.Fatalf("Failed to parse email: %v", err) t.Fatalf("Failed to parse email: %v", err)
} }
analyzer := NewRspamdAnalyzer() analyzer := NewRspamdAnalyzer(nil)
result := analyzer.AnalyzeRspamd(email) result := analyzer.AnalyzeRspamd(email)
if result == nil { if result == nil {

10
pkg/analyzer/scoring.go
View file

@ -22,7 +22,7 @@
package analyzer package analyzer
import ( import (
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
) )
// ScoreToGrade converts a percentage score (0-100) to a letter grade // ScoreToGrade converts a percentage score (0-100) to a letter grade
@ -65,14 +65,16 @@ func ScoreToGradeKind(score int) string {
} }
} }
// ScoreToReportGrade converts a percentage score to an api.ReportGrade // ScoreToReportGrade converts a percentage score to an model.ReportGrade
func ScoreToReportGrade(score int) api.ReportGrade { func ScoreToReportGrade(score int) model.ReportGrade {
return api.ReportGrade(ScoreToGrade(score)) return model.ReportGrade(ScoreToGrade(score))
} }
// gradeRank returns a numeric rank for a grade (lower = worse) // gradeRank returns a numeric rank for a grade (lower = worse)
func gradeRank(grade string) int { func gradeRank(grade string) int {
switch grade { switch grade {
case "A++":
return 7
case "A+": case "A+":
return 6 return 6
case "A": case "A":

33
pkg/analyzer/spamassassin.go
View file

@ -27,7 +27,8 @@ import (
"strconv" "strconv"
"strings" "strings"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
// SpamAssassinAnalyzer analyzes SpamAssassin results from email headers // SpamAssassinAnalyzer analyzes SpamAssassin results from email headers
@ -39,14 +40,22 @@ func NewSpamAssassinAnalyzer() *SpamAssassinAnalyzer {
} }
// AnalyzeSpamAssassin extracts and analyzes SpamAssassin results from email headers // AnalyzeSpamAssassin extracts and analyzes SpamAssassin results from email headers
func (a *SpamAssassinAnalyzer) AnalyzeSpamAssassin(email *EmailMessage) *api.SpamAssassinResult { func (a *SpamAssassinAnalyzer) AnalyzeSpamAssassin(email *EmailMessage) *model.SpamAssassinResult {
headers := email.GetSpamAssassinHeaders() headers := email.GetSpamAssassinHeaders()
if len(headers) == 0 { if len(headers) == 0 {
return nil return nil
} }
result := &api.SpamAssassinResult{ // Require at least X-Spam-Status, X-Spam-Score, or X-Spam-Flag to produce a meaningful report
TestDetails: make(map[string]api.SpamTestDetail), _, hasStatus := headers["X-Spam-Status"]
_, hasScore := headers["X-Spam-Score"]
_, hasFlag := headers["X-Spam-Flag"]
if !hasStatus && !hasScore && !hasFlag {
return nil
}
result := &model.SpamAssassinResult{
TestDetails: make(map[string]model.SpamTestDetail),
} }
// Parse X-Spam-Status header // Parse X-Spam-Status header
@ -68,13 +77,13 @@ func (a *SpamAssassinAnalyzer) AnalyzeSpamAssassin(email *EmailMessage) *api.Spa
// Parse X-Spam-Report header for detailed test results // Parse X-Spam-Report header for detailed test results
if reportHeader, ok := headers["X-Spam-Report"]; ok { if reportHeader, ok := headers["X-Spam-Report"]; ok {
result.Report = api.PtrTo(strings.Replace(reportHeader, " * ", "\n* ", -1)) result.Report = utils.PtrTo(strings.Replace(reportHeader, " * ", "\n* ", -1))
a.parseSpamReport(reportHeader, result) a.parseSpamReport(reportHeader, result)
} }
// Parse X-Spam-Checker-Version // Parse X-Spam-Checker-Version
if versionHeader, ok := headers["X-Spam-Checker-Version"]; ok { if versionHeader, ok := headers["X-Spam-Checker-Version"]; ok {
result.Version = api.PtrTo(strings.TrimSpace(versionHeader)) result.Version = utils.PtrTo(strings.TrimSpace(versionHeader))
} }
return result return result
@ -82,7 +91,7 @@ func (a *SpamAssassinAnalyzer) AnalyzeSpamAssassin(email *EmailMessage) *api.Spa
// parseSpamStatus parses the X-Spam-Status header // parseSpamStatus parses the X-Spam-Status header
// Format: Yes/No, score=5.5 required=5.0 tests=TEST1,TEST2,TEST3 autolearn=no // Format: Yes/No, score=5.5 required=5.0 tests=TEST1,TEST2,TEST3 autolearn=no
func (a *SpamAssassinAnalyzer) parseSpamStatus(header string, result *api.SpamAssassinResult) { func (a *SpamAssassinAnalyzer) parseSpamStatus(header string, result *model.SpamAssassinResult) {
// Check if spam (first word) // Check if spam (first word)
parts := strings.SplitN(header, ",", 2) parts := strings.SplitN(header, ",", 2)
if len(parts) > 0 { if len(parts) > 0 {
@ -126,7 +135,7 @@ func (a *SpamAssassinAnalyzer) parseSpamStatus(header string, result *api.SpamAs
// * 0.0 TEST_NAME Description line 1 // * 0.0 TEST_NAME Description line 1
// * continuation line 2 // * continuation line 2
// * continuation line 3 // * continuation line 3
func (a *SpamAssassinAnalyzer) parseSpamReport(report string, result *api.SpamAssassinResult) { func (a *SpamAssassinAnalyzer) parseSpamReport(report string, result *model.SpamAssassinResult) {
segments := strings.Split(report, "*") segments := strings.Split(report, "*")
// Regex to match test lines: score TEST_NAME Description // Regex to match test lines: score TEST_NAME Description
@ -148,7 +157,7 @@ func (a *SpamAssassinAnalyzer) parseSpamReport(report string, result *api.SpamAs
// Save previous test if exists // Save previous test if exists
if currentTestName != "" { if currentTestName != "" {
description := strings.TrimSpace(currentDescription.String()) description := strings.TrimSpace(currentDescription.String())
detail := api.SpamTestDetail{ detail := model.SpamTestDetail{
Name: currentTestName, Name: currentTestName,
Score: result.TestDetails[currentTestName].Score, Score: result.TestDetails[currentTestName].Score,
Description: &description, Description: &description,
@ -166,7 +175,7 @@ func (a *SpamAssassinAnalyzer) parseSpamReport(report string, result *api.SpamAs
currentDescription.WriteString(description) currentDescription.WriteString(description)
// Initialize with score // Initialize with score
result.TestDetails[testName] = api.SpamTestDetail{ result.TestDetails[testName] = model.SpamTestDetail{
Name: testName, Name: testName,
Score: float32(score), Score: float32(score),
} }
@ -183,7 +192,7 @@ func (a *SpamAssassinAnalyzer) parseSpamReport(report string, result *api.SpamAs
// Save the last test if exists // Save the last test if exists
if currentTestName != "" { if currentTestName != "" {
description := strings.TrimSpace(currentDescription.String()) description := strings.TrimSpace(currentDescription.String())
detail := api.SpamTestDetail{ detail := model.SpamTestDetail{
Name: currentTestName, Name: currentTestName,
Score: result.TestDetails[currentTestName].Score, Score: result.TestDetails[currentTestName].Score,
Description: &description, Description: &description,
@ -193,7 +202,7 @@ func (a *SpamAssassinAnalyzer) parseSpamReport(report string, result *api.SpamAs
} }
// CalculateSpamAssassinScore calculates the SpamAssassin contribution to deliverability // CalculateSpamAssassinScore calculates the SpamAssassin contribution to deliverability
func (a *SpamAssassinAnalyzer) CalculateSpamAssassinScore(result *api.SpamAssassinResult) (int, string) { func (a *SpamAssassinAnalyzer) CalculateSpamAssassinScore(result *model.SpamAssassinResult) (int, string) {
if result == nil { if result == nil {
return 100, "" // No spam scan results, assume good return 100, "" // No spam scan results, assume good
} }

33
pkg/analyzer/spamassassin_test.go
View file

@ -27,7 +27,8 @@ import (
"strings" "strings"
"testing" "testing"
"git.happydns.org/happyDeliver/internal/api" "git.happydns.org/happyDeliver/internal/model"
"git.happydns.org/happyDeliver/internal/utils"
) )
func TestParseSpamStatus(t *testing.T) { func TestParseSpamStatus(t *testing.T) {
@ -77,8 +78,8 @@ func TestParseSpamStatus(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
result := &api.SpamAssassinResult{ result := &model.SpamAssassinResult{
TestDetails: make(map[string]api.SpamTestDetail), TestDetails: make(map[string]model.SpamTestDetail),
} }
analyzer.parseSpamStatus(tt.header, result) analyzer.parseSpamStatus(tt.header, result)
@ -115,27 +116,27 @@ func TestParseSpamReport(t *testing.T) {
` `
analyzer := NewSpamAssassinAnalyzer() analyzer := NewSpamAssassinAnalyzer()
result := &api.SpamAssassinResult{ result := &model.SpamAssassinResult{
TestDetails: make(map[string]api.SpamTestDetail), TestDetails: make(map[string]model.SpamTestDetail),
} }
analyzer.parseSpamReport(report, result) analyzer.parseSpamReport(report, result)
expectedTests := map[string]api.SpamTestDetail{ expectedTests := map[string]model.SpamTestDetail{
"BAYES_99": { "BAYES_99": {
Name: "BAYES_99", Name: "BAYES_99",
Score: 5.0, Score: 5.0,
Description: api.PtrTo("Bayes spam probability is 99 to 100%"), Description: utils.PtrTo("Bayes spam probability is 99 to 100%"),
}, },
"SPOOFED_SENDER": { "SPOOFED_SENDER": {
Name: "SPOOFED_SENDER", Name: "SPOOFED_SENDER",
Score: 3.5, Score: 3.5,
Description: api.PtrTo("From address doesn't match envelope sender"), Description: utils.PtrTo("From address doesn't match envelope sender"),
}, },
"ALL_TRUSTED": { "ALL_TRUSTED": {
Name: "ALL_TRUSTED", Name: "ALL_TRUSTED",
Score: -1.0, Score: -1.0,
Description: api.PtrTo("All mail servers are trusted"), Description: utils.PtrTo("All mail servers are trusted"),
}, },
} }
@ -157,7 +158,7 @@ func TestParseSpamReport(t *testing.T) {
func TestGetSpamAssassinScore(t *testing.T) { func TestGetSpamAssassinScore(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
result *api.SpamAssassinResult result *model.SpamAssassinResult
expectedScore int expectedScore int
minScore int minScore int
maxScore int maxScore int
@ -169,7 +170,7 @@ func TestGetSpamAssassinScore(t *testing.T) {
}, },
{ {
name: "Excellent score (negative)", name: "Excellent score (negative)",
result: &api.SpamAssassinResult{ result: &model.SpamAssassinResult{
Score: -2.5, Score: -2.5,
RequiredScore: 5.0, RequiredScore: 5.0,
}, },
@ -177,7 +178,7 @@ func TestGetSpamAssassinScore(t *testing.T) {
}, },
{ {
name: "Good score (below threshold)", name: "Good score (below threshold)",
result: &api.SpamAssassinResult{ result: &model.SpamAssassinResult{
Score: 2.0, Score: 2.0,
RequiredScore: 5.0, RequiredScore: 5.0,
}, },
@ -185,7 +186,7 @@ func TestGetSpamAssassinScore(t *testing.T) {
}, },
{ {
name: "Score at threshold", name: "Score at threshold",
result: &api.SpamAssassinResult{ result: &model.SpamAssassinResult{
Score: 5.0, Score: 5.0,
RequiredScore: 5.0, RequiredScore: 5.0,
}, },
@ -193,7 +194,7 @@ func TestGetSpamAssassinScore(t *testing.T) {
}, },
{ {
name: "Above threshold (spam)", name: "Above threshold (spam)",
result: &api.SpamAssassinResult{ result: &model.SpamAssassinResult{
Score: 6.0, Score: 6.0,
RequiredScore: 5.0, RequiredScore: 5.0,
}, },
@ -201,7 +202,7 @@ func TestGetSpamAssassinScore(t *testing.T) {
}, },
{ {
name: "High spam score", name: "High spam score",
result: &api.SpamAssassinResult{ result: &model.SpamAssassinResult{
Score: 12.0, Score: 12.0,
RequiredScore: 5.0, RequiredScore: 5.0,
}, },
@ -209,7 +210,7 @@ func TestGetSpamAssassinScore(t *testing.T) {
}, },
{ {
name: "Very high spam score", name: "Very high spam score",
result: &api.SpamAssassinResult{ result: &model.SpamAssassinResult{
Score: 20.0, Score: 20.0,
RequiredScore: 5.0, RequiredScore: 5.0,
}, },

2
web/package.json
View file

@ -31,7 +31,7 @@
"prettier-plugin-svelte": "^3.4.0", "prettier-plugin-svelte": "^3.4.0",
"svelte": "^5.39.5", "svelte": "^5.39.5",
"svelte-check": "^4.3.2", "svelte-check": "^4.3.2",
"typescript": "^5.9.2", "typescript": "^6.0.0",
"typescript-eslint": "^8.44.1", "typescript-eslint": "^8.44.1",
"vite": "^8.0.0", "vite": "^8.0.0",
"vitest": "^3.2.4" "vitest": "^3.2.4"

5
web/routes.go
View file

@ -70,6 +70,10 @@ func DeclareRoutes(cfg *config.Config, router *gin.Engine) {
appConfig["custom_logo_url"] = cfg.CustomLogoURL appConfig["custom_logo_url"] = cfg.CustomLogoURL
} }
if !cfg.DisableTestList {
appConfig["test_list_enabled"] = true
}
if appcfg, err := json.MarshalIndent(appConfig, "", " "); err != nil { if appcfg, err := json.MarshalIndent(appConfig, "", " "); err != nil {
log.Println("Unable to generate JSON config to inject in web application") log.Println("Unable to generate JSON config to inject in web application")
} else { } else {
@ -95,6 +99,7 @@ func DeclareRoutes(cfg *config.Config, router *gin.Engine) {
router.GET("/domain/:domain", serveOrReverse("/", cfg)) router.GET("/domain/:domain", serveOrReverse("/", cfg))
router.GET("/test/", serveOrReverse("/", cfg)) router.GET("/test/", serveOrReverse("/", cfg))
router.GET("/test/:testid", serveOrReverse("/", cfg)) router.GET("/test/:testid", serveOrReverse("/", cfg))
router.GET("/history/", serveOrReverse("/", cfg))
router.GET("/favicon.png", func(c *gin.Context) { c.Writer.Header().Set("Cache-Control", "public, max-age=604800, immutable") }, serveOrReverse("", cfg)) router.GET("/favicon.png", func(c *gin.Context) { c.Writer.Header().Set("Cache-Control", "public, max-age=604800, immutable") }, serveOrReverse("", cfg))
router.GET("/img/*path", serveOrReverse("", cfg)) router.GET("/img/*path", serveOrReverse("", cfg))

28
web/src/lib/components/AuthenticationCard.svelte
View file

@ -13,6 +13,12 @@
let { authentication, authenticationGrade, authenticationScore, dnsResults }: Props = $props(); let { authentication, authenticationGrade, authenticationScore, dnsResults }: Props = $props();
let allRequiredMissing = $derived(
!authentication.spf &&
(!authentication.dkim || authentication.dkim.length === 0) &&
!authentication.dmarc,
);
function getAuthResultClass(result: string, noneIsFail: boolean): string { function getAuthResultClass(result: string, noneIsFail: boolean): string {
switch (result) { switch (result) {
case "pass": case "pass":
@ -97,6 +103,28 @@
</span> </span>
</h4> </h4>
</div> </div>
{#if allRequiredMissing}
<div class="card-body border-bottom">
<div class="alert alert-warning mb-0">
<i class="bi bi-exclamation-triangle-fill me-2"></i>
<strong>No authentication results found.</strong>
<p class="mb-0 mt-1">
This usually means either:
</p>
<ul class="mb-0 mt-1">
<li>
The receiving mail server is not configured to verify email authentication
(no <code>Authentication-Results</code> header was found in the message).
</li>
<li>
The <code>Authentication-Results</code> header exists but the receiver
hostname does not match the configured
<code>--receiver-hostname</code> value.
</li>
</ul>
</div>
</div>
{/if}
<div class="list-group list-group-flush"> <div class="list-group list-group-flush">
<!-- IPREV --> <!-- IPREV -->
{#if authentication.iprev} {#if authentication.iprev}

2
web/src/lib/components/HeaderAnalysisCard.svelte
View file

@ -11,7 +11,7 @@
headerScore?: number; headerScore?: number;
} }
let { dmarcRecord, headerAnalysis, headerGrade, headerScore, xAlignedFrom }: Props = $props(); let { dmarcRecord, headerAnalysis, headerGrade, headerScore }: Props = $props();
</script> </script>
<div class="card shadow-sm" id="header-details"> <div class="card shadow-sm" id="header-details">

72
web/src/lib/components/HistoryTable.svelte Normal file
View file

@ -0,0 +1,72 @@
<script lang="ts">
import { goto } from "$app/navigation";
import type { TestSummary } from "$lib/api/types.gen";
import GradeDisplay from "./GradeDisplay.svelte";
interface Props {
tests: TestSummary[];
}
let { tests }: Props = $props();
function formatDate(dateStr: string): string {
const date = new Date(dateStr);
return date.toLocaleDateString(undefined, {
year: "numeric",
month: "short",
day: "numeric",
hour: "2-digit",
minute: "2-digit",
});
}
</script>
<div class="table-responsive shadow-sm">
<table class="table table-hover mb-0 align-middle">
<thead>
<tr>
<th class="ps-4" style="width: 80px;">Grade</th>
<th style="width: 80px;">Score</th>
<th>Domain</th>
<th>Date</th>
<th style="width: 50px;"></th>
</tr>
</thead>
<tbody>
{#each tests as test}
<tr class="cursor-pointer" onclick={() => goto(`/test/${test.test_id}`)}>
<td class="ps-4">
<GradeDisplay grade={test.grade} size="small" />
</td>
<td>
<span class="badge bg-secondary">{test.score}%</span>
</td>
<td>
{#if test.from_domain}
<code>{test.from_domain}</code>
{:else}
<span class="text-muted">-</span>
{/if}
</td>
<td class="text-muted">
{formatDate(test.created_at)}
</td>
<td>
<i class="bi bi-chevron-right text-muted"></i>
</td>
</tr>
{/each}
</tbody>
</table>
</div>
<style>
.cursor-pointer {
cursor: pointer;
}
.cursor-pointer:hover td {
background-color: var(--bs-tertiary-bg);
}
</style>

13
web/src/lib/components/RspamdCard.svelte
View file

@ -75,7 +75,7 @@
<tr> <tr>
<th>Symbol</th> <th>Symbol</th>
<th class="text-end">Score</th> <th class="text-end">Score</th>
<th>Parameters</th> <th>Description</th>
</tr> </tr>
</thead> </thead>
<tbody> <tbody>
@ -87,7 +87,14 @@
? "table-success" ? "table-success"
: ""} : ""}
> >
<td class="font-monospace">{symbolName}</td> <td>
<span class="font-monospace">{symbolName}</span>
{#if symbol.params}
<small class="d-block text-muted">
{symbol.params}
</small>
{/if}
</td>
<td class="text-end"> <td class="text-end">
<span <span
class={symbol.score > 0 class={symbol.score > 0
@ -99,7 +106,7 @@
{symbol.score > 0 ? "+" : ""}{symbol.score.toFixed(2)} {symbol.score > 0 ? "+" : ""}{symbol.score.toFixed(2)}
</span> </span>
</td> </td>
<td class="small text-muted">{symbol.params ?? ""}</td> <td class="small text-muted">{symbol.description ?? ""}</td>
</tr> </tr>
{/each} {/each}
</tbody> </tbody>

28
web/src/lib/components/SummaryCard.svelte
View file

@ -25,16 +25,32 @@
// Email sender information // Email sender information
const mailFrom = report.header_analysis?.headers?.from?.value || "an unknown sender"; const mailFrom = report.header_analysis?.headers?.from?.value || "an unknown sender";
const hasDkim = report.authentication?.dkim && report.authentication?.dkim.length > 0; const hasDkim =
const dkimPassed = hasDkim && report.authentication?.dkim?.some((d) => d.result === "pass"); report.dns_results?.dkim_records && report.dns_results?.dkim_records?.length > 0;
const dkimPassed =
report.authentication?.dkim &&
report.authentication?.dkim.length > 0 &&
report.authentication?.dkim?.some((d) => d.result === "pass");
segments.push({ text: "Received a " }); segments.push({ text: "Received a " });
segments.push({ segments.push({
text: dkimPassed ? "DKIM-signed" : "non-DKIM-signed", text: hasDkim ? "DKIM-signed" : "non-DKIM-signed",
highlight: { color: dkimPassed ? "good" : "danger", bold: true }, highlight: {
link: "#authentication-dkim", color: hasDkim ? (dkimPassed ? "good" : "warning") : "danger",
bold: true,
},
link: hasDkim && dkimPassed ? "#authentication-dkim" : "#dns-details",
}); });
segments.push({ text: " email from " }); segments.push({ text: " email" });
if (hasDkim && !dkimPassed) {
segments.push({ text: " with " });
segments.push({
text: "an invalid signature",
highlight: { color: "danger", bold: true },
link: "#authentication-dkim",
});
}
segments.push({ text: " from " });
segments.push({ segments.push({
text: mailFrom, text: mailFrom,
highlight: { emphasis: true }, highlight: { emphasis: true },

1
web/src/lib/components/index.ts
View file

@ -23,5 +23,6 @@ export { default as RspamdCard } from "./RspamdCard.svelte";
export { default as SpamAssassinCard } from "./SpamAssassinCard.svelte"; export { default as SpamAssassinCard } from "./SpamAssassinCard.svelte";
export { default as SpfRecordsDisplay } from "./SpfRecordsDisplay.svelte"; export { default as SpfRecordsDisplay } from "./SpfRecordsDisplay.svelte";
export { default as SummaryCard } from "./SummaryCard.svelte"; export { default as SummaryCard } from "./SummaryCard.svelte";
export { default as HistoryTable } from "./HistoryTable.svelte";
export { default as TinySurvey } from "./TinySurvey.svelte"; export { default as TinySurvey } from "./TinySurvey.svelte";
export { default as WhitelistCard } from "./WhitelistCard.svelte"; export { default as WhitelistCard } from "./WhitelistCard.svelte";

1
web/src/lib/stores/config.ts
View file

@ -26,6 +26,7 @@ interface AppConfig {
survey_url?: string; survey_url?: string;
custom_logo_url?: string; custom_logo_url?: string;
rbls?: string[]; rbls?: string[];
test_list_enabled?: boolean;
} }
const defaultConfig: AppConfig = { const defaultConfig: AppConfig = {

12
web/src/routes/+layout.svelte
View file

@ -40,7 +40,17 @@
<Logo color={$theme === "light" ? "black" : "white"} /> <Logo color={$theme === "light" ? "black" : "white"} />
{/if} {/if}
</a> </a>
<div> {#if $appConfig.test_list_enabled}
<ul class="navbar-nav me-auto">
<li class="nav-item">
<a class="nav-link" href="/history/">
<i class="bi bi-clock-history me-1"></i>
History
</a>
</li>
</ul>
{/if}
<div class="d-flex align-items-center">
<span class="d-none d-md-inline navbar-text text-primary small"> <span class="d-none d-md-inline navbar-text text-primary small">
Open-Source Email Deliverability Tester Open-Source Email Deliverability Tester
</span> </span>

48
web/src/routes/+page.svelte
View file

@ -1,12 +1,30 @@
<script lang="ts"> <script lang="ts">
import { goto } from "$app/navigation"; import { goto } from "$app/navigation";
import { createTest as apiCreateTest } from "$lib/api"; import { createTest as apiCreateTest, listTests } from "$lib/api";
import { FeatureCard, HowItWorksStep } from "$lib/components"; import type { TestSummary } from "$lib/api/types.gen";
import { FeatureCard, HowItWorksStep, HistoryTable } from "$lib/components";
import { appConfig } from "$lib/stores/config"; import { appConfig } from "$lib/stores/config";
let loading = $state(false); let loading = $state(false);
let error = $state<string | null>(null); let error = $state<string | null>(null);
let recentTests = $state<TestSummary[]>([]);
async function loadRecentTests() {
if (!$appConfig.test_list_enabled) return;
try {
const response = await listTests({ query: { offset: 0, limit: 5 } });
if (response.data) {
recentTests = response.data.tests;
}
} catch {
// Silently ignore — this is a non-critical section
}
}
$effect(() => {
loadRecentTests();
});
async function createTest() { async function createTest() {
loading = true; loading = true;
@ -176,6 +194,32 @@
</div> </div>
</section> </section>
<!-- Recently Tested -->
{#if $appConfig.test_list_enabled && recentTests.length > 0}
<section class="py-5 border-bottom border-3" id="recent">
<div class="container py-4">
<div class="row text-center mb-5">
<div class="col-lg-8 mx-auto">
<h2 class="display-5 fw-bold mb-3">Recently Tested</h2>
<p class="text-muted">Latest deliverability reports from this instance</p>
</div>
</div>
<div class="row">
<div class="col-lg-10 mx-auto">
<HistoryTable tests={recentTests} />
<div class="text-center mt-4">
<a href="/history/" class="btn btn-outline-primary">
<i class="bi bi-clock-history me-2"></i>
View All Tests
</a>
</div>
</div>
</div>
</div>
</section>
{/if}
<!-- Features Section --> <!-- Features Section -->
<section class="py-5" id="features"> <section class="py-5" id="features">
<div class="container py-4"> <div class="container py-4">

189
web/src/routes/history/+page.svelte Normal file
View file

@ -0,0 +1,189 @@
<script lang="ts">
import { goto } from "$app/navigation";
import { listTests, createTest as apiCreateTest } from "$lib/api";
import type { TestSummary } from "$lib/api/types.gen";
import { HistoryTable } from "$lib/components";
let tests = $state<TestSummary[]>([]);
let total = $state(0);
let offset = $state(0);
let limit = $state(20);
let loading = $state(true);
let error = $state<string | null>(null);
let creatingTest = $state(false);
async function loadTests() {
loading = true;
error = null;
try {
const response = await listTests({ query: { offset, limit } });
if (response.data) {
tests = response.data.tests;
total = response.data.total;
} else if (response.error) {
if (
response.error &&
typeof response.error === "object" &&
"error" in response.error &&
response.error.error === "feature_disabled"
) {
error = "Test listing is disabled on this instance.";
} else {
error = "Failed to load tests.";
}
}
} catch (err) {
error = err instanceof Error ? err.message : "Failed to load tests.";
} finally {
loading = false;
}
}
$effect(() => {
loadTests();
});
function goToPage(newOffset: number) {
offset = newOffset;
loadTests();
}
async function createTest() {
creatingTest = true;
try {
const response = await apiCreateTest();
if (response.data) {
goto(`/test/${response.data.id}`);
}
} catch (err) {
error = err instanceof Error ? err.message : "Failed to create test";
} finally {
creatingTest = false;
}
}
let totalPages = $derived(Math.ceil(total / limit));
let currentPage = $derived(Math.floor(offset / limit) + 1);
</script>
<svelte:head>
<title>Test History - happyDeliver</title>
</svelte:head>
<div class="container py-5">
<div class="row">
<div class="col-lg-10 mx-auto">
<div class="d-flex justify-content-between align-items-center mb-4">
<h1 class="display-6 fw-bold mb-0">
<i class="bi bi-clock-history me-2"></i>
Test History
</h1>
<button
class="btn btn-primary"
onclick={createTest}
disabled={creatingTest}
>
{#if creatingTest}
<span
class="spinner-border spinner-border-sm me-2"
role="status"
></span>
{:else}
<i class="bi bi-plus-lg me-1"></i>
{/if}
New Test
</button>
</div>
{#if loading}
<div class="text-center py-5">
<div
class="spinner-border text-primary"
role="status"
style="width: 3rem; height: 3rem;"
>
<span class="visually-hidden">Loading...</span>
</div>
<p class="mt-3 text-muted">Loading tests...</p>
</div>
{:else if error}
<div class="alert alert-warning text-center" role="alert">
<i class="bi bi-exclamation-triangle me-2"></i>
{error}
</div>
{:else if tests.length === 0}
<div class="text-center py-5">
<i
class="bi bi-inbox display-1 text-muted mb-3 d-block"
></i>
<h2 class="h4 text-muted mb-3">No tests yet</h2>
<p class="text-muted mb-4">
Send a test email to get your first deliverability
report.
</p>
<button
class="btn btn-primary btn-lg"
onclick={createTest}
disabled={creatingTest}
>
<i class="bi bi-envelope-plus me-2"></i>
Start Your First Test
</button>
</div>
{:else}
<HistoryTable {tests} />
<!-- Pagination -->
{#if totalPages > 1}
<nav class="mt-4 d-flex justify-content-between align-items-center">
<small class="text-muted">
Showing {offset + 1}-{Math.min(
offset + limit,
total,
)} of {total} tests
</small>
<ul class="pagination mb-0">
<li
class="page-item"
class:disabled={currentPage === 1}
>
<button
class="page-link"
onclick={() =>
goToPage(
Math.max(0, offset - limit),
)}
disabled={currentPage === 1}
>
<i class="bi bi-chevron-left"></i>
Previous
</button>
</li>
<li class="page-item disabled">
<span class="page-link">
Page {currentPage} of {totalPages}
</span>
</li>
<li
class="page-item"
class:disabled={currentPage === totalPages}
>
<button
class="page-link"
onclick={() =>
goToPage(offset + limit)}
disabled={currentPage === totalPages}
>
Next
<i class="bi bi-chevron-right"></i>
</button>
</li>
</ul>
</nav>
{/if}
{/if}
</div>
</div>
</div>