Update go dependencies

Bumps [actions/setup-go](https://github.com/actions/setup-go) from 6.4.0 to 6.5.0.
- [Release notes](https://github.com/actions/setup-go/releases)
- [Commits](https://github.com/actions/setup-go/compare/4a3601121dd01d1626a1e23e37211e3254c1c06c...924ae3a1cded613372ab5595356fb5720e22ba16)

---
updated-dependencies:
- dependency-name: actions/setup-go
  dependency-version: 6.5.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/workflows/codeql-analysis.yml

@@ -38,16 +38,16 @@ jobs:
 
     steps:
     - name: Harden Runner
-      uses: step-security/harden-runner@0634a2670c59f64b4a01f0f96f84700a4088b9f0 # v2.12.0
+      uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411 # v2.19.4
       with:
         egress-policy: audit
 
     - name: Checkout repository
-      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@fca7ace96b7d713c7035871441bd52efbe39e27e # v3.28.19
+      uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -58,7 +58,7 @@ jobs:
     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
-      uses: github/codeql-action/autobuild@fca7ace96b7d713c7035871441bd52efbe39e27e # v3.28.19
+      uses: github/codeql-action/autobuild@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -72,4 +72,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@fca7ace96b7d713c7035871441bd52efbe39e27e # v3.28.19
+      uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2

.github/workflows/dependency-review.yml

@@ -17,11 +17,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@0634a2670c59f64b4a01f0f96f84700a4088b9f0 # v2.12.0
+        uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411 # v2.19.4
         with:
           egress-policy: audit
 
       - name: 'Checkout Repository'
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: 'Dependency Review'
-        uses: actions/dependency-review-action@da24556b548a50705dd671f47852072ea4c105d9 # v4.7.1
+        uses: actions/dependency-review-action@a1d282b36b6f3519aa1f3fc636f609c47dddb294 # v5.0.0

.github/workflows/go.yml

@@ -10,12 +10,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Harden Runner
-      uses: step-security/harden-runner@0634a2670c59f64b4a01f0f96f84700a4088b9f0 # v2.12.0
+      uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411 # v2.19.4
       with:
         egress-policy: audit
 
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-    - uses: actions/setup-go@d35c59abb061a4a6fb18e82ac0862c26744d6ab5 # v5.5.0
+    - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+    - uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
       with:
         go-version: 'stable'
 

.github/workflows/release.yaml

@@ -3,6 +3,12 @@ name: Release Go Binaries
 on:
   release:
     types: [created]
+  workflow_dispatch:
+    inputs:
+      release_tag:
+        description: 'Tag name to build (v1.3.1)'
+        required: false
+        default: ''
 
 # Declare default permissions as read only.
 permissions: read-all
@@ -21,22 +27,37 @@ jobs:
 
     steps:
     - name: Harden Runner
-      uses: step-security/harden-runner@0634a2670c59f64b4a01f0f96f84700a4088b9f0 # v2.12.0
+      uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411 # v2.19.4
       with:
         egress-policy: audit
 
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+    - name: Determine ref to checkout
+      run: |
+        # If manually invoked with a release_tag input, use refs/tags/<release_tag>.
+        if [ "${{ github.event_name }}" = "workflow_dispatch" ] && [ -n "${{ github.event.inputs.release_tag }}" ]; then
+          echo "REF=refs/tags/${{ github.event.inputs.release_tag }}" >> $GITHUB_ENV
+        else
+          # For release events GITHUB_REF is already refs/tags/<tag>; otherwise fall back to the incoming ref.
+          echo "REF=${GITHUB_REF}" >> $GITHUB_ENV
+        fi
+
+    - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      with:
+        ref: ${{ env.REF }}
 
     - name: Set APP_VERSION env
-      run: echo APP_VERSION=$(echo ${GITHUB_REF} | rev | cut -d'/' -f 1 | rev ) >> ${GITHUB_ENV}
+      run: |
+        # basename strips refs/... and yields the tag or branch name
+        echo "APP_VERSION=$(basename ${REF})" >> $GITHUB_ENV
+
     - name: Set BUILD_TIME env
       run: echo BUILD_TIME=$(date) >> ${GITHUB_ENV}
       
-    - uses: wangyoucao577/go-release-action@481a2c1a0f1be199722e3e9b74d7199acafc30a8 # v1.53
+    - uses: wangyoucao577/go-release-action@279495102627de7960cbc33434ab01a12bae144b # v1.55
       with:
         github_token: ${{ secrets.GITHUB_TOKEN }}
         goos: ${{ matrix.goos }}
         goarch: ${{ matrix.goarch }}
-        goversion: "1.24"
         extra_files: LICENSE README.md smtprelay.ini
         ldflags: -s -w -X "main.appVersion=${{ env.APP_VERSION }}" -X "main.buildTime=${{ env.BUILD_TIME }}"
+        release_tag: ${{ env.APP_VERSION }}

.github/workflows/scorecards.yml

@@ -36,17 +36,17 @@ jobs:
 
     steps:
       - name: Harden Runner
-        uses: step-security/harden-runner@0634a2670c59f64b4a01f0f96f84700a4088b9f0 # v2.12.0
+        uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411 # v2.19.4
         with:
           egress-policy: audit
 
       - name: "Checkout code"
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           persist-credentials: false
 
       - name: "Run analysis"
-        uses: ossf/scorecard-action@05b42c624433fc40578a4040d5cf5e36ddca8cde # v2.4.2
+        uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
         with:
           results_file: results.sarif
           results_format: sarif
@@ -68,7 +68,7 @@ jobs:
       # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
       # format to the repository Actions tab.
       - name: "Upload artifact"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: SARIF file
           path: results.sarif
@@ -76,6 +76,6 @@ jobs:
 
       # Upload the results to GitHub's code scanning dashboard.
       - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@fca7ace96b7d713c7035871441bd52efbe39e27e # v3.28.19
+        uses: github/codeql-action/upload-sarif@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
         with:
           sarif_file: results.sarif

README.md

@@ -31,3 +31,4 @@ device which produces mail.
 * Forwards all mail to a smarthost (any SMTP server)
 * Small codebase
 * IPv6 support
+* Aliases support (dynamic reload when alias file changes)

aliases.go

@@ -0,0 +1,72 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+)
+
+type AliasMap map[string]string
+
+var (
+	aliasesMutex sync.RWMutex
+)
+
+func AliasLoadFile(file string) (AliasMap, error) {
+	aliasMap := make(AliasMap)
+	count := 0
+	log.Info().
+		Str("file", file).
+		Msg("Loading aliases file")
+
+	f, err := os.Open(file)
+	if err != nil {
+		log.Fatal().
+			Str("file", file).
+			Err(err).
+			Msg("cannot load aliases file")
+	}
+	defer f.Close()
+
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+
+		parts := strings.Fields(line)
+		if len(parts) >= 2 {
+			aliasMap[parts[0]] = parts[1]
+			count++
+		}
+	}
+	log.Info().
+		Str("file", file).
+		Msg(fmt.Sprintf("Loaded %d aliases from file", count))
+
+	if err := scanner.Err(); err != nil {
+		log.Fatal().
+			Str("file", file).
+			Err(err).
+			Msg("cannot load aliases file")
+	}
+	return aliasMap, nil
+}
+
+func LoadAliases(filename string) error {
+	newAliases, err := AliasLoadFile(filename)
+	if err != nil {
+		return err
+	}
+
+	aliasesMutex.Lock()
+	defer aliasesMutex.Unlock()
+
+	// Update the aliases map
+	aliasesList = newAliases
+
+	return nil
+}

aliases_test.go

@@ -0,0 +1,315 @@
+package main
+
+import (
+	"io"
+	"os"
+	"testing"
+
+	"github.com/rs/zerolog"
+)
+
+func init() {
+	// Initialize logger for tests to prevent nil pointer dereference
+	logger := zerolog.New(io.Discard).With().Timestamp().Logger()
+	log = &logger
+}
+func TestAliasLoadFile(t *testing.T) {
+	tests := []struct {
+		name        string
+		content     string
+		expected    AliasMap
+		expectError bool
+	}{
+		{
+			name:    "valid aliases",
+			content: "user1 alias1\nuser2 alias2\nuser3 alias3",
+			expected: AliasMap{
+				"user1": "alias1",
+				"user2": "alias2",
+				"user3": "alias3",
+			},
+			expectError: false,
+		},
+		{
+			name:        "empty file",
+			content:     "",
+			expected:    AliasMap{},
+			expectError: false,
+		},
+		{
+			name:    "file with empty lines",
+			content: "user1 alias1\n\nuser2 alias2\n\n",
+			expected: AliasMap{
+				"user1": "alias1",
+				"user2": "alias2",
+			},
+			expectError: false,
+		},
+		{
+			name:    "file with whitespace",
+			content: "  user1   alias1  \n\t user2\talias2\t",
+			expected: AliasMap{
+				"user1": "alias1",
+				"user2": "alias2",
+			},
+			expectError: false,
+		},
+		{
+			name:    "extra fields ignored",
+			content: "user1 alias1 extra field\nuser2 alias2",
+			expected: AliasMap{
+				"user1": "alias1",
+				"user2": "alias2",
+			},
+			expectError: false,
+		},
+		{
+			name:        "single field line ignored",
+			content:     "user1\nuser2 alias2",
+			expected:    AliasMap{"user2": "alias2"},
+			expectError: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpFile, err := os.CreateTemp("", "aliases-*.txt")
+			if err != nil {
+				t.Fatalf("failed to create temp file: %v", err)
+			}
+			defer os.Remove(tmpFile.Name())
+
+			if _, err := tmpFile.WriteString(tt.content); err != nil {
+				t.Fatalf("failed to write to temp file: %v", err)
+			}
+			tmpFile.Close()
+
+			result, err := AliasLoadFile(tmpFile.Name())
+
+			if tt.expectError && err == nil {
+				t.Error("expected error but got none")
+			}
+			if !tt.expectError && err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
+
+			if len(result) != len(tt.expected) {
+				t.Errorf("expected %d aliases, got %d", len(tt.expected), len(result))
+			}
+
+			for key, expectedValue := range tt.expected {
+				if actualValue, exists := result[key]; !exists {
+					t.Errorf("expected key %q not found", key)
+				} else if actualValue != expectedValue {
+					t.Errorf("for key %q: expected %q, got %q", key, expectedValue, actualValue)
+				}
+			}
+		})
+	}
+}
+
+func TestLoadAliases(t *testing.T) {
+	tmpFile, err := os.CreateTemp("", "aliases-*.txt")
+	if err != nil {
+		t.Fatalf("failed to create temp file: %v", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	content := "user1 alias1\nuser2 alias2"
+	if _, err := tmpFile.WriteString(content); err != nil {
+		t.Fatalf("failed to write to temp file: %v", err)
+	}
+	tmpFile.Close()
+
+	err = LoadAliases(tmpFile.Name())
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	aliasesMutex.RLock()
+	defer aliasesMutex.RUnlock()
+
+	if len(aliasesList) != 2 {
+		t.Errorf("expected 2 aliases, got %d", len(aliasesList))
+	}
+
+	if aliasesList["user1"] != "alias1" {
+		t.Errorf("expected user1 -> alias1, got %q", aliasesList["user1"])
+	}
+	if aliasesList["user2"] != "alias2" {
+		t.Errorf("expected user2 -> alias2, got %q", aliasesList["user2"])
+	}
+}
+
+func TestLoadAliases_EmptyFile(t *testing.T) {
+	tmpFile, err := os.CreateTemp("", "aliases-*.txt")
+	if err != nil {
+		t.Fatalf("failed to create temp file: %v", err)
+	}
+	defer os.Remove(tmpFile.Name())
+	tmpFile.Close()
+
+	err = LoadAliases(tmpFile.Name())
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	aliasesMutex.RLock()
+	defer aliasesMutex.RUnlock()
+
+	if len(aliasesList) != 0 {
+		t.Errorf("expected 0 aliases, got %d", len(aliasesList))
+	}
+}
+
+func TestLoadAliases_UpdatesExistingAliases(t *testing.T) {
+	// First load
+	tmpFile1, err := os.CreateTemp("", "aliases-*.txt")
+	if err != nil {
+		t.Fatalf("failed to create temp file: %v", err)
+	}
+	defer os.Remove(tmpFile1.Name())
+
+	content1 := "user1 alias1\nuser2 alias2"
+	if _, err := tmpFile1.WriteString(content1); err != nil {
+		t.Fatalf("failed to write to temp file: %v", err)
+	}
+	tmpFile1.Close()
+
+	err = LoadAliases(tmpFile1.Name())
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	// Second load with different content
+	tmpFile2, err := os.CreateTemp("", "aliases-*.txt")
+	if err != nil {
+		t.Fatalf("failed to create temp file: %v", err)
+	}
+	defer os.Remove(tmpFile2.Name())
+
+	content2 := "user3 alias3"
+	if _, err := tmpFile2.WriteString(content2); err != nil {
+		t.Fatalf("failed to write to temp file: %v", err)
+	}
+	tmpFile2.Close()
+
+	err = LoadAliases(tmpFile2.Name())
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	aliasesMutex.RLock()
+	defer aliasesMutex.RUnlock()
+
+	if len(aliasesList) != 1 {
+		t.Errorf("expected 1 alias after reload, got %d", len(aliasesList))
+	}
+
+	if aliasesList["user3"] != "alias3" {
+		t.Errorf("expected user3 -> alias3, got %q", aliasesList["user3"])
+	}
+
+	if _, exists := aliasesList["user1"]; exists {
+		t.Error("expected user1 to be removed after reload")
+	}
+}
+
+func TestAliasLoadFile_MultipleSpaces(t *testing.T) {
+	tmpFile, err := os.CreateTemp("", "aliases-*.txt")
+	if err != nil {
+		t.Fatalf("failed to create temp file: %v", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	content := "user1     alias1\nuser2          alias2"
+	if _, err := tmpFile.WriteString(content); err != nil {
+		t.Fatalf("failed to write to temp file: %v", err)
+	}
+	tmpFile.Close()
+
+	result, err := AliasLoadFile(tmpFile.Name())
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	if result["user1"] != "alias1" {
+		t.Errorf("expected user1 -> alias1, got %q", result["user1"])
+	}
+	if result["user2"] != "alias2" {
+		t.Errorf("expected user2 -> alias2, got %q", result["user2"])
+	}
+}
+
+func TestAliasLoadFile_TabSeparated(t *testing.T) {
+	tmpFile, err := os.CreateTemp("", "aliases-*.txt")
+	if err != nil {
+		t.Fatalf("failed to create temp file: %v", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	content := "user1\talias1\nuser2\t\talias2"
+	if _, err := tmpFile.WriteString(content); err != nil {
+		t.Fatalf("failed to write to temp file: %v", err)
+	}
+	tmpFile.Close()
+
+	result, err := AliasLoadFile(tmpFile.Name())
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	if len(result) != 2 {
+		t.Errorf("expected 2 aliases, got %d", len(result))
+	}
+}
+
+func TestAliasLoadFile_DuplicateKeys(t *testing.T) {
+	tmpFile, err := os.CreateTemp("", "aliases-*.txt")
+	if err != nil {
+		t.Fatalf("failed to create temp file: %v", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	content := "user1 alias1\nuser1 alias2\nuser1 alias3"
+	if _, err := tmpFile.WriteString(content); err != nil {
+		t.Fatalf("failed to write to temp file: %v", err)
+	}
+	tmpFile.Close()
+
+	result, err := AliasLoadFile(tmpFile.Name())
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	if len(result) != 1 {
+		t.Errorf("expected 1 alias (last one wins), got %d", len(result))
+	}
+
+	if result["user1"] != "alias3" {
+		t.Errorf("expected user1 -> alias3 (last one), got %q", result["user1"])
+	}
+}
+
+func TestAliasLoadFile_OnlyWhitespace(t *testing.T) {
+	tmpFile, err := os.CreateTemp("", "aliases-*.txt")
+	if err != nil {
+		t.Fatalf("failed to create temp file: %v", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	content := "   \n\t\t\n  \t  \n"
+	if _, err := tmpFile.WriteString(content); err != nil {
+		t.Fatalf("failed to write to temp file: %v", err)
+	}
+	tmpFile.Close()
+
+	result, err := AliasLoadFile(tmpFile.Name())
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	if len(result) != 0 {
+		t.Errorf("expected 0 aliases, got %d", len(result))
+	}
+}

config.go

@@ -12,7 +12,6 @@ import (
 	"time"
 
 	"github.com/peterbourgon/ff/v3"
-	"github.com/sirupsen/logrus"
 )
 
 var (
@@ -32,6 +31,7 @@ var (
 	listenStr        = flagset.String("listen", "127.0.0.1:25 [::1]:25", "Address and port to listen for incoming SMTP")
 	localCert        = flagset.String("local_cert", "", "SSL certificate for STARTTLS/TLS")
 	localKey         = flagset.String("local_key", "", "SSL private key for STARTTLS/TLS")
+	tlsProfile       = flagset.String("tls_profile", "default", "TLS profile: modern | intermediate | default | legacy")
 	localForceTLS    = flagset.Bool("local_forcetls", false, "Force STARTTLS (needs local_cert and local_key)")
 	readTimeoutStr   = flagset.String("read_timeout", "60s", "Socket timeout for read operations")
 	writeTimeoutStr  = flagset.String("write_timeout", "60s", "Socket timeout for write operations")
@@ -43,9 +43,12 @@ var (
 	allowedSenderStr = flagset.String("allowed_sender", "", "Regular expression for valid FROM EMail addresses")
 	allowedRecipStr  = flagset.String("allowed_recipients", "", "Regular expression for valid TO EMail addresses")
 	allowedUsers     = flagset.String("allowed_users", "", "Path to file with valid users/passwords")
+	aliasFile        = flagset.String("aliases_file", "", "Path to aliases file")
 	command          = flagset.String("command", "", "Path to pipe command")
 	remotesStr       = flagset.String("remotes", "", "Outgoing SMTP servers")
 	strictSender     = flagset.Bool("strict_sender", false, "Use only SMTP servers with Sender matches to From")
+	remoteCert       = flagset.String("remote_certificate", "", "Client SSL certificate for remote STARTTLS/TLS")
+	remoteKey        = flagset.String("remote_key", "", "Client SSL private key for remote STARTTLS/TLS")
 
 	// additional flags
 	_           = flagset.String("config", "", "Path to config file (ini format)")
@@ -60,28 +63,73 @@ var (
 	allowedSender     *regexp.Regexp
 	allowedRecipients *regexp.Regexp
 	remotes           = []*Remote{}
+	aliasesList       = AliasMap{}
 )
 
 func localAuthRequired() bool {
 	return *allowedUsers != ""
 }
 
+func remoteCertAndKeyReadable() bool {
+	certSet := *remoteCert != ""
+	keySet := *remoteKey != ""
+	
+	// Both must be set or both must be unset
+	if certSet != keySet {
+		return false
+	}
+	
+	// If both are set, verify files exist and are accessible
+	if certSet && keySet {
+		if _, err := os.Stat(*remoteCert); err != nil {
+			log.Error().
+				Str("cert", *remoteCert).
+				Err(err).
+				Msg("cannot access remote client certificate file")
+			return false
+		}
+		if _, err := os.Stat(*remoteKey); err != nil {
+			log.Error().
+				Str("key", *remoteKey).
+				Err(err).
+				Msg("cannot access remote client key file")
+			return false
+		}
+	}
+	
+	return true
+}
+
+func setupAliases() {
+	if *aliasFile != "" {
+		aliases, err := AliasLoadFile(*aliasFile)
+		if err != nil {
+			log.Fatal().
+				Str("file", *aliasFile).
+				Err(err).
+				Msg("cannot load aliases file")
+		}
+		aliasesList = aliases
+	}
+}
+
 func setupAllowedNetworks() {
 	for _, netstr := range splitstr(*allowedNetsStr, ' ') {
 		baseIP, allowedNet, err := net.ParseCIDR(netstr)
 		if err != nil {
-			log.WithField("netstr", netstr).
-				WithError(err).
-				Fatal("Invalid CIDR notation in allowed_nets")
+			log.Fatal().
+				Str("netstr", netstr).
+				Err(err).
+				Msg("Invalid CIDR notation in allowed_nets")
 		}
 
 		// Reject any network specification where any host bits are set,
 		// meaning the address refers to a host and not a network.
 		if !allowedNet.IP.Equal(baseIP) {
-			log.WithFields(logrus.Fields{
-				"given_net":  netstr,
-				"proper_net": allowedNet,
-			}).Fatal("Invalid network in allowed_nets (host bits set)")
+			log.Fatal().
+				Str("given_net", netstr).
+				Str("proper_net", allowedNet.String()).
+				Msg("Invalid network in allowed_nets (host bits set)")
 		}
 
 		allowedNets = append(allowedNets, allowedNet)
@@ -94,30 +142,37 @@ func setupAllowedPatterns() {
 	if *allowedSenderStr != "" {
 		allowedSender, err = regexp.Compile(*allowedSenderStr)
 		if err != nil {
-			log.WithField("allowed_sender", *allowedSenderStr).
-				WithError(err).
-				Fatal("allowed_sender pattern invalid")
+			log.Fatal().
+				Str("allowed_sender", *allowedSenderStr).
+				Err(err).
+				Msg("allowed_sender pattern invalid")
 		}
 	}
 
 	if *allowedRecipStr != "" {
 		allowedRecipients, err = regexp.Compile(*allowedRecipStr)
 		if err != nil {
-			log.WithField("allowed_recipients", *allowedRecipStr).
-				WithError(err).
-				Fatal("allowed_recipients pattern invalid")
+			log.Fatal().
+				Str("allowed_recipients", *allowedRecipStr).
+				Err(err).
+				Msg("allowed_recipients pattern invalid")
 		}
 	}
 }
 
 func setupRemotes() {
-	logger := log.WithField("remotes", *remotesStr)
+	logger := log.With().Str("remotes", *remotesStr).Logger()
 
 	if *remotesStr != "" {
 		for _, remoteURL := range strings.Split(*remotesStr, " ") {
 			r, err := ParseRemote(remoteURL)
 			if err != nil {
-				logger.Fatal(fmt.Sprintf("error parsing url: '%s': %v", remoteURL, err))
+				logger.Fatal().Msg(fmt.Sprintf("error parsing url: '%s': %v", remoteURL, err))
+			}
+
+			if *remoteCert != "" && *remoteKey != "" && (r.Scheme == "smtps" || r.Scheme == "starttls") {
+				r.ClientCertPath = *remoteCert
+				r.ClientKeyPath = *remoteKey
 			}
 
 			remotes = append(remotes, r)
@@ -148,8 +203,9 @@ func setupListeners() {
 		pa := splitProto(listenAddr)
 
 		if localAuthRequired() && pa.protocol == "" {
-			log.WithField("address", pa.address).
-				Fatal("Local authentication (via allowed_users file) " +
+			log.Fatal().
+				Str("address", pa.address).
+				Msg("Local authentication (via allowed_users file) " +
 					"not allowed with non-TLS listener")
 		}
 
@@ -162,35 +218,41 @@ func setupTimeouts() {
 
 	readTimeout, err = time.ParseDuration(*readTimeoutStr)
 	if err != nil {
-		log.WithField("read_timeout", *readTimeoutStr).
-			WithError(err).
-			Fatal("read_timeout duration string invalid")
+		log.Fatal().
+			Str("read_timeout", *readTimeoutStr).
+			Err(err).
+			Msg("read_timeout duration string invalid")
 	}
 	if readTimeout.Seconds() < 1 {
-		log.WithField("read_timeout", *readTimeoutStr).
-			Fatal("read_timeout less than one second")
+		log.Fatal().
+			Str("read_timeout", *readTimeoutStr).
+			Msg("read_timeout less than one second")
 	}
 
 	writeTimeout, err = time.ParseDuration(*writeTimeoutStr)
 	if err != nil {
-		log.WithField("write_timeout", *writeTimeoutStr).
-			WithError(err).
-			Fatal("write_timeout duration string invalid")
+		log.Fatal().
+			Str("write_timeout", *writeTimeoutStr).
+			Err(err).
+			Msg("write_timeout duration string invalid")
 	}
 	if writeTimeout.Seconds() < 1 {
-		log.WithField("write_timeout", *writeTimeoutStr).
-			Fatal("write_timeout less than one second")
+		log.Fatal().
+			Str("write_timeout", *writeTimeoutStr).
+			Msg("write_timeout less than one second")
 	}
 
 	dataTimeout, err = time.ParseDuration(*dataTimeoutStr)
 	if err != nil {
-		log.WithField("data_timeout", *dataTimeoutStr).
-			WithError(err).
-			Fatal("data_timeout duration string invalid")
+		log.Fatal().
+			Str("data_timeout", *dataTimeoutStr).
+			Err(err).
+			Msg("data_timeout duration string invalid")
 	}
 	if dataTimeout.Seconds() < 1 {
-		log.WithField("data_timeout", *dataTimeoutStr).
-			Fatal("data_timeout less than one second")
+		log.Fatal().
+			Str("data_timeout", *dataTimeoutStr).
+			Msg("data_timeout less than one second")
 	}
 }
 
@@ -226,11 +288,19 @@ func ConfigLoad() {
 	}
 
 	if *remotesStr == "" && *command == "" {
-		log.Warn("no remotes or command set; mail will not be forwarded!")
+		log.Warn().Msg("no remotes or command set; mail will not be forwarded!")
+	}
+
+	if !remoteCertAndKeyReadable() {
+		log.Fatal().
+			Str("remote_certificate", *remoteCert).
+			Str("remote_key", *remoteKey).
+			Msg("remote_certificate and remote_key must both be set or both be empty")
 	}
 
 	setupAllowedNetworks()
 	setupAllowedPatterns()
+	setupAliases()
 	setupRemotes()
 	setupListeners()
 	setupTimeouts()

go.mod

@@ -1,21 +1,24 @@
 module github.com/decke/smtprelay
 
 require (
-	github.com/chrj/smtpd v0.3.1
+	github.com/DeRuina/timberjack v1.4.5
+	github.com/chrj/smtpd v1.0.0
+	github.com/fsnotify/fsnotify v1.10.1
 	github.com/google/uuid v1.6.0
 	github.com/peterbourgon/ff/v3 v3.4.0
-	github.com/sirupsen/logrus v1.9.3
-	github.com/stretchr/testify v1.10.0
-	golang.org/x/crypto v0.38.0
+	github.com/rs/zerolog v1.35.1
+	github.com/stretchr/testify v1.11.1
+	golang.org/x/crypto v0.53.0
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/kr/pretty v0.3.1 // indirect
+	github.com/klauspost/compress v1.18.6 // indirect
+	github.com/mattn/go-colorable v0.1.15 // indirect
+	github.com/mattn/go-isatty v0.0.22 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	golang.org/x/sys v0.33.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
+	golang.org/x/sys v0.46.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
-go 1.24.3
+go 1.25.0

go.sum

@@ -1,39 +1,34 @@
-github.com/chrj/smtpd v0.3.1 h1:kogHFkbFdKaoH3bgZkqNC9uVtKYOFfM3uV3rroBdooE=
-github.com/chrj/smtpd v0.3.1/go.mod h1:JtABvV/LzvLmEIzy0NyDnrfMGOMd8wy5frAokwf6J9Q=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/DeRuina/timberjack v1.4.5 h1:F/kms5MPNAXUeWdOILt5ALC6iDHWNRPevaeIVH7tqYU=
+github.com/DeRuina/timberjack v1.4.5/go.mod h1:RLoeQrwrCGIEF8gO5nV5b/gMD0QIy7bzQhBUgpp1EqE=
+github.com/chrj/smtpd v1.0.0 h1:jChSfLzAhrSxTky0EZ6oW+UKiqdnepdknWYRkPeA+ZE=
+github.com/chrj/smtpd v1.0.0/go.mod h1:zEP61gNDlWp/jdUqBcq/ykIbgOERyRvwfMsRLl3h9gM=
 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/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw=
+github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
+github.com/fsnotify/fsnotify v1.10.1 h1:b0/UzAf9yR5rhf3RPm9gf3ehBPpf0oZKIjtpKrx59Ho=
+github.com/fsnotify/fsnotify v1.10.1/go.mod h1:TLheqan6HD6GBK6PrDWyDPBaEV8LspOxvPSjC+bVfgo=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao=
+github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
+github.com/mattn/go-colorable v0.1.15 h1:+u9SLTRGnXv73cEsnsmoZBom+dMU88B2M0aDcWy0/jY=
+github.com/mattn/go-colorable v0.1.15/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.22 h1:j8l17JJ9i6VGPUFUYoTUKPSgKe/83EYU2zBC7YNKMw4=
+github.com/mattn/go-isatty v0.0.22/go.mod h1:ZXfXG4SQHsB/w3ZeOYbR0PrPwLy+n6xiMrJlRFqopa4=
 github.com/peterbourgon/ff/v3 v3.4.0 h1:QBvM/rizZM1cB0p0lGMdmR7HxZeI/ZrBWB4DqLkMUBc=
 github.com/peterbourgon/ff/v3 v3.4.0/go.mod h1:zjJVUhx+twciwfDl0zBcFzl4dW8axCRyXE/eKY9RztQ=
-github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 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/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
-github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
-github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
-github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
-golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
-golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+github.com/rs/zerolog v1.35.1 h1:m7xQeoiLIiV0BCEY4Hs+j2NG4Gp2o2KPKmhnnLiazKI=
+github.com/rs/zerolog v1.35.1/go.mod h1:EjML9kdfa/RMA7h/6z6pYmq1ykOuA8/mjWaEvGI+jcw=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto=
+golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio=
+golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

logger.go

@@ -2,59 +2,84 @@ package main
 
 import (
 	"fmt"
+	"io"
 	"os"
+	"strings"
 	"time"
 
-	"github.com/sirupsen/logrus"
+	"github.com/DeRuina/timberjack"
+	"github.com/rs/zerolog"
 )
 
 var (
-	log *logrus.Logger
+	rotator *timberjack.Logger
+	log     *zerolog.Logger
 )
 
 func setupLogger() {
-	log = logrus.New()
+	zerolog.TimeFieldFormat = time.RFC3339
 
 	// Handle logfile
+	var writer io.Writer
 	if *logFile == "" {
-		log.SetOutput(os.Stderr)
+		writer = os.Stderr
 	} else {
-		writer, err := os.OpenFile(*logFile, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0600)
-		if err != nil {
-			fmt.Printf("cannot open log file: %s\n", err)
-			os.Exit(1)
+		rotator = &timberjack.Logger{
+			Filename:         *logFile,
+			MaxSize:          10, // megabytes before rotation
+			MaxBackups:       3,
+			MaxAge:           30, // days
+			Compress:         true,
+			BackupTimeFormat: "20060102150405",
 		}
-
-		log.SetOutput(writer)
+		writer = rotator
 	}
 
 	// Handle log_format
 	switch *logFormat {
 	case "json":
-		log.SetFormatter(&logrus.JSONFormatter{
-			TimestampFormat:   time.RFC3339Nano,
-			DisableHTMLEscape: true,
-		})
+		// zerolog default is JSON
 	case "plain":
-		log.SetFormatter(&logrus.TextFormatter{
-			DisableTimestamp: true,
-		})
+		writer = zerolog.ConsoleWriter{
+			Out:        writer,
+			NoColor:    true,
+			TimeFormat: "",
+			FormatTimestamp: func(i interface{}) string {
+				return "" // avoid default time
+			},
+		}
 	case "", "default":
-		log.SetFormatter(&logrus.TextFormatter{
-			FullTimestamp: true,
-		})
+		writer = zerolog.ConsoleWriter{
+			Out:        writer,
+			NoColor:    true,
+			TimeFormat: time.RFC3339,
+		}
+	case "pretty":
+		writer = zerolog.ConsoleWriter{
+			Out:        writer,
+			TimeFormat: time.RFC3339Nano,
+		}
 	default:
 		fmt.Fprintf(os.Stderr, "Invalid log_format: %s\n", *logFormat)
 		os.Exit(1)
 	}
 
-	// Handle log_level
-	level, err := logrus.ParseLevel(*logLevel)
-	if err != nil {
-		level = logrus.InfoLevel
+	l := zerolog.New(writer).With().Timestamp().Logger()
+	log = &l
 
-		log.WithField("given_level", *logLevel).
-			Warn("could not parse log level, defaulting to 'info'")
+	// Handle log_level
+	level, err := zerolog.ParseLevel(strings.ToLower(*logLevel))
+	if err != nil {
+		level = zerolog.InfoLevel
+		log.Warn().Str("given_level", *logLevel).
+			Msg("could not parse log level, defaulting to 'info'")
+	}
+	zerolog.SetGlobalLevel(level)
+}
+
+// Call this on shutdown if you want to close the rotator and stop timers cleanly
+func closeLogger() {
+	if rotator != nil {
+		rotator.Close()
 	}
-	log.SetLevel(level)
 }

main.go

@@ -13,8 +13,8 @@ import (
 	"syscall"
 
 	"github.com/chrj/smtpd"
+	"github.com/fsnotify/fsnotify"
 	"github.com/google/uuid"
-	"github.com/sirupsen/logrus"
 )
 
 func connectionChecker(peer smtpd.Peer) error {
@@ -32,9 +32,9 @@ func connectionChecker(peer smtpd.Peer) error {
 		}
 	}
 
-	log.WithFields(logrus.Fields{
-		"ip": peerIP,
-	}).Warn("Connection refused from address outside of allowed_nets")
+	log.Warn().
+		Str("ip", peerIP.String()).
+		Msg("Connection refused from address outside of allowed_nets")
 	return smtpd.Error{Code: 421, Message: "Denied"}
 }
 
@@ -87,19 +87,21 @@ func senderChecker(peer smtpd.Peer, addr string) error {
 		user, err := AuthFetch(peer.Username)
 		if err != nil {
 			// Shouldn't happen: authChecker already validated username+password
-			log.WithFields(logrus.Fields{
-				"peer":     peer.Addr,
-				"username": peer.Username,
-			}).WithError(err).Warn("could not fetch auth user")
+			log.Warn().
+				Str("peer", peer.Addr.String()).
+				Str("username", peer.Username).
+				Err(err).
+				Msg("could not fetch auth user")
 			return smtpd.Error{Code: 451, Message: "Bad sender address"}
 		}
 
 		if !addrAllowed(addr, user.allowedAddresses) {
-			log.WithFields(logrus.Fields{
-				"peer":           peer.Addr,
-				"username":       peer.Username,
-				"sender_address": addr,
-			}).Warn("sender address not allowed for authenticated user")
+			log.Warn().
+				Str("peer", peer.Addr.String()).
+				Str("username", peer.Username).
+				Str("sender_address", addr).
+				Err(err).
+				Msg("sender address not allowed for authenticated user")
 			return smtpd.Error{Code: 451, Message: "Bad sender address"}
 		}
 	}
@@ -114,10 +116,10 @@ func senderChecker(peer smtpd.Peer, addr string) error {
 		return nil
 	}
 
-	log.WithFields(logrus.Fields{
-		"sender_address": addr,
-		"peer":           peer.Addr,
-	}).Warn("sender address not allowed by allowed_sender pattern")
+	log.Warn().
+		Str("sender_address", addr).
+		Str("peer", peer.Addr.String()).
+		Msg("sender address not allowed by allowed_sender pattern")
 	return smtpd.Error{Code: 451, Message: "Bad sender address"}
 }
 
@@ -132,20 +134,21 @@ func recipientChecker(peer smtpd.Peer, addr string) error {
 		return nil
 	}
 
-	log.WithFields(logrus.Fields{
-		"peer":              peer.Addr,
-		"recipient_address": addr,
-	}).Warn("recipient address not allowed by allowed_recipients pattern")
+	log.Warn().
+		Str("peer", peer.Addr.String()).
+		Str("recipient_address", addr).
+		Msg("recipient address not allowed by allowed_recipients pattern")
 	return smtpd.Error{Code: 451, Message: "Bad recipient address"}
 }
 
 func authChecker(peer smtpd.Peer, username string, password string) error {
 	err := AuthCheckPassword(username, password)
 	if err != nil {
-		log.WithFields(logrus.Fields{
-			"peer":     peer.Addr,
-			"username": username,
-		}).WithError(err).Warn("auth error")
+		log.Warn().
+			Str("peer", peer.Addr.String()).
+			Str("username", username).
+			Err(err).
+			Msg("auth error")
 		return smtpd.Error{Code: 535, Message: "Authentication credentials invalid"}
 	}
 	return nil
@@ -157,12 +160,25 @@ func mailHandler(peer smtpd.Peer, env smtpd.Envelope) error {
 		peerIP = addr.IP.String()
 	}
 
-	logger := log.WithFields(logrus.Fields{
-		"from": env.Sender,
-		"to":   env.Recipients,
-		"peer": peerIP,
-		"uuid": generateUUID(),
-	})
+	// Check for aliases
+	aliasesMutex.RLock()
+	for i, recipient := range env.Recipients {
+		if alias, exists := aliasesList[recipient]; exists {
+			env.Recipients[i] = alias
+			log.Info().
+				Str("original_recipient", recipient).
+				Str("aliased_recipient", alias).
+				Msg("Recipient address aliased")
+		}
+	}
+	aliasesMutex.RUnlock()
+
+	logger := log.With().
+		Str("from", env.Sender).
+		Strs("to", env.Recipients).
+		Str("peer", peerIP).
+		Str("uuid", generateUUID()).
+		Logger()
 
 	var envRemotes []*Remote
 
@@ -177,14 +193,14 @@ func mailHandler(peer smtpd.Peer, env smtpd.Envelope) error {
 	}
 
 	if len(envRemotes) == 0 && *command == "" {
-		logger.Warning("no remote_host or command set; discarding mail")
+		logger.Warn().Msg("no remote_host or command set; discarding mail")
 		return smtpd.Error{Code: 554, Message: "There are no appropriate remote_host or command"}
 	}
 
 	env.AddReceivedLine(peer)
 
 	if *command != "" {
-		cmdLogger := logger.WithField("command", *command)
+		cmdLogger := logger.With().Str("command", *command).Logger()
 
 		var stdout bytes.Buffer
 		var stderr bytes.Buffer
@@ -205,16 +221,16 @@ func mailHandler(peer smtpd.Peer, env smtpd.Envelope) error {
 
 		err := cmd.Run()
 		if err != nil {
-			cmdLogger.WithError(err).Error(stderr.String())
+			cmdLogger.Error().Err(err).Msg(stderr.String())
 			return smtpd.Error{Code: 554, Message: "External command failed"}
 		}
 
-		cmdLogger.Info("pipe command successful: " + stdout.String())
+		cmdLogger.Info().Msg("pipe command successful: " + stdout.String())
 	}
 
 	for _, remote := range envRemotes {
-		logger = logger.WithField("host", remote.Addr)
-		logger.Info("delivering mail from peer using smarthost")
+		logger = logger.With().Str("host", remote.Addr).Logger()
+		logger.Info().Msg("delivering mail from peer using smarthost")
 
 		err := SendMail(
 			remote,
@@ -229,21 +245,22 @@ func mailHandler(peer smtpd.Peer, env smtpd.Envelope) error {
 			case *textproto.Error:
 				smtpError = smtpd.Error{Code: err.Code, Message: err.Msg}
 
-				logger.WithFields(logrus.Fields{
-					"err_code": err.Code,
-					"err_msg":  err.Msg,
-				}).Error("delivery failed")
+				logger.Error().
+					Int("err_code", err.Code).
+					Str("err_msg", err.Msg).
+					Msg("delivery failed")
 			default:
 				smtpError = smtpd.Error{Code: 421, Message: "Forwarding failed"}
 
-				logger.WithError(err).
-					Error("delivery failed")
+				logger.Error().
+					Err(err).
+					Msg("delivery failed")
 			}
 
 			return smtpError
 		}
 
-		logger.Debug("delivery successful")
+		logger.Debug().Msg("delivery successful")
 	}
 
 	return nil
@@ -253,8 +270,9 @@ func generateUUID() string {
 	uniqueID, err := uuid.NewRandom()
 
 	if err != nil {
-		log.WithError(err).
-			Error("could not generate UUIDv4")
+		log.Error().
+			Err(err).
+			Msg("could not generate UUIDv4")
 
 		return ""
 	}
@@ -263,64 +281,168 @@ func generateUUID() string {
 }
 
 func getTLSConfig() *tls.Config {
-	// Ciphersuites as defined in stock Go but without 3DES and RC4
-	// https://golang.org/src/crypto/tls/cipher_suites.go
-	var tlsCipherSuites = []uint16{
-		tls.TLS_AES_128_GCM_SHA256,
-		tls.TLS_AES_256_GCM_SHA384,
-		tls.TLS_CHACHA20_POLY1305_SHA256,
-		tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
-		tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
-		tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-		tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-		tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
-		tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
-		tls.TLS_RSA_WITH_AES_128_GCM_SHA256, // does not provide PFS
-		tls.TLS_RSA_WITH_AES_256_GCM_SHA384, // does not provide PFS
-	}
-
+	// Certificate loading / validation
 	if *localCert == "" || *localKey == "" {
-		log.WithFields(logrus.Fields{
-			"cert_file": *localCert,
-			"key_file":  *localKey,
-		}).Fatal("TLS certificate/key file not defined in config")
+		log.Fatal().
+			Str("cert_file", *localCert).
+			Str("key_file", *localKey).
+			Msg("TLS certificate/key file not defined in config")
 	}
 
 	cert, err := tls.LoadX509KeyPair(*localCert, *localKey)
 	if err != nil {
-		log.WithField("error", err).
-			Fatal("cannot load X509 keypair")
+		log.Fatal().
+			Err(err).
+			Msg("cannot load X509 keypair")
 	}
 
-	return &tls.Config{
-		PreferServerCipherSuites: true,
-		MinVersion:               tls.VersionTLS12,
-		CipherSuites:             tlsCipherSuites,
+	// TLS profile configuration
+	// tls.Config.CipherSuites only affects TLS 1.0–1.2.
+
+	// Base config: Go defaults unless overridden.
+	conf := &tls.Config{
 		Certificates: []tls.Certificate{cert},
 	}
+
+	profile := strings.ToLower(strings.TrimSpace(*tlsProfile))
+	if profile == "" {
+		profile = "default"
+	}
+
+	switch profile {
+	case "default":
+		// Go defaults (leave MinVersion/MaxVersion/CipherSuites unset).
+
+	case "modern":
+		// TLS 1.3+.
+		conf.MinVersion = tls.VersionTLS13
+
+	case "intermediate":
+		// TLS 1.2+ with AEAD + ECDHE cipher suites only.
+		// Mozilla "intermediate" — AEAD + ECDHE only.
+		conf.MinVersion = tls.VersionTLS12
+		conf.CipherSuites = []uint16{
+			tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+			tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+			tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+			tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+			tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
+			tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+		}
+
+	case "legacy":
+		// Last resort: TLS 1.0+ and everything Go exposes for TLS 1.0–1.2.
+		conf.MinVersion = tls.VersionTLS10
+
+		allSuites := []uint16{}
+		for _, cs := range tls.CipherSuites() {
+			allSuites = append(allSuites, cs.ID)
+		}
+		for _, cs := range tls.InsecureCipherSuites() {
+			allSuites = append(allSuites, cs.ID)
+		}
+		conf.CipherSuites = allSuites
+
+	default:
+		log.Warn().
+			Str("tls_profile", profile).
+			Msg("unknown tls_profile; using default")
+	}
+
+	return conf
+}
+
+func watchAliasFile() {
+	if *aliasFile == "" {
+		return
+	}
+
+	watcher, err := fsnotify.NewWatcher()
+	if err != nil {
+		log.Error().
+			Err(err).
+			Msg("failed to create file watcher for alias file")
+		return
+	}
+
+	go func() {
+		defer watcher.Close()
+
+		for {
+			select {
+			case event, ok := <-watcher.Events:
+				if !ok {
+					return
+				}
+
+				if event.Has(fsnotify.Write) || event.Has(fsnotify.Create) {
+					log.Info().
+						Str("file", event.Name).
+						Msg("alias file changed, reloading")
+
+					err := LoadAliases(*aliasFile)
+					if err != nil {
+						log.Error().
+							Str("file", *aliasFile).
+							Err(err).
+							Msg("failed to reload alias file")
+					} else {
+						log.Info().
+							Int("count", len(aliasesList)).
+							Msg("alias file reloaded successfully")
+					}
+				}
+
+			case err, ok := <-watcher.Errors:
+				if !ok {
+					return
+				}
+				log.Error().
+					Err(err).
+					Msg("file watcher error")
+			}
+		}
+	}()
+
+	err = watcher.Add(*aliasFile)
+	if err != nil {
+		log.Error().
+			Str("file", *aliasFile).
+			Err(err).
+			Msg("failed to watch alias file")
+	} else {
+		log.Info().
+			Str("file", *aliasFile).
+			Msg("watching alias file for changes")
+	}
 }
 
 func main() {
 	ConfigLoad()
 
-	log.WithField("version", appVersion).
-		Debug("starting smtprelay")
+	log.Debug().
+		Str("version", appVersion).
+		Msg("starting smtprelay")
 
 	// Load allowed users file
 	if localAuthRequired() {
 		err := AuthLoadFile(*allowedUsers)
 		if err != nil {
-			log.WithField("file", *allowedUsers).
-				WithError(err).
-				Fatal("cannot load allowed users file")
+			log.Fatal().
+				Str("file", *allowedUsers).
+				Err(err).
+				Msg("cannot load allowed users file")
 		}
 	}
 
+	// Start watching alias file for changes
+	watchAliasFile()
+
 	var servers []*smtpd.Server
 
 	// Create a server for each desired listen address
 	for _, listen := range listenAddrs {
-		logger := log.WithField("address", listen.address)
+		logger := log.With().Str("address", listen.address).Logger()
 
 		server := &smtpd.Server{
 			Hostname:          *hostName,
@@ -346,29 +468,32 @@ func main() {
 
 		switch listen.protocol {
 		case "":
-			logger.Info("listening on address")
+			logger.Info().Msg("listening on address")
 			lsnr, err = net.Listen("tcp", listen.address)
 
 		case "starttls":
 			server.TLSConfig = getTLSConfig()
 			server.ForceTLS = *localForceTLS
 
-			logger.Info("listening on address (STARTTLS)")
+			logger.Info().Msg("listening on address (STARTTLS)")
 			lsnr, err = net.Listen("tcp", listen.address)
 
 		case "tls":
 			server.TLSConfig = getTLSConfig()
 
-			logger.Info("listening on address (TLS)")
+			logger.Info().Msg("listening on address (TLS)")
 			lsnr, err = tls.Listen("tcp", listen.address, server.TLSConfig)
 
 		default:
-			logger.WithField("protocol", listen.protocol).
-				Fatal("unknown protocol in listen address")
+			logger.Fatal().
+				Str("protocol", listen.protocol).
+				Msg("unknown protocol in listen address")
 		}
 
 		if err != nil {
-			logger.WithError(err).Fatal("error starting listener")
+			logger.Fatal().
+				Err(err).
+				Msg("error starting listener")
 		}
 		servers = append(servers, server)
 
@@ -381,27 +506,31 @@ func main() {
 
 	// First close the listeners
 	for _, server := range servers {
-		logger := log.WithField("address", server.Address())
-		logger.Debug("Shutting down server")
+		logger := log.With().Str("address", server.Address().String()).Logger()
+		logger.Debug().Msg("Shutting down server")
 		err := server.Shutdown(false)
 		if err != nil {
-			logger.WithError(err).
-				Warning("Shutdown failed")
+			logger.Warn().
+				Err(err).
+				Msg("Shutdown failed")
 		}
 	}
 
 	// Then wait for the clients to exit
 	for _, server := range servers {
-		logger := log.WithField("address", server.Address())
-		logger.Debug("Waiting for server")
+		logger := log.With().Str("address", server.Address().String()).Logger()
+		logger.Debug().Msg("Waiting for server")
 		err := server.Wait()
 		if err != nil {
-			logger.WithError(err).
-				Warning("Wait failed")
+			logger.Warn().
+				Err(err).
+				Msg("Wait failed")
 		}
 	}
 
-	log.Debug("done")
+	log.Debug().Msg("done")
+
+	closeLogger()
 }
 
 func handleSignals() {
@@ -410,6 +539,7 @@ func handleSignals() {
 	signal.Notify(sigs, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM)
 	sig := <-sigs
 
-	log.WithField("signal", sig).
-		Info("shutting down in response to received signal")
+	log.Info().
+		Str("signal", sig.String()).
+		Msg("shutting down in response to received signal")
 }

remotes.go

@@ -14,6 +14,8 @@ type Remote struct {
 	Port            string
 	Addr            string
 	Sender          string
+	ClientCertPath  string
+	ClientKeyPath   string
 }
 
 // ParseRemote creates a remote from a given url in the following format:

smtp.go

@@ -340,6 +340,14 @@ func SendMail(r *Remote, from string, to []string, msg []byte) error {
 			ServerName:         r.Hostname,
 			InsecureSkipVerify: r.SkipVerify,
 		}
+		// Load client certificate on-demand, just before connection
+		if r.ClientCertPath != "" && r.ClientKeyPath != "" {
+			cert, err := tls.LoadX509KeyPair(r.ClientCertPath, r.ClientKeyPath)
+			if err != nil {
+				return err
+			}
+			config.Certificates = []tls.Certificate{cert}
+		}
 		conn, err := tls.Dial("tcp", r.Addr, config)
 		if err != nil {
 			return err
@@ -366,6 +374,14 @@ func SendMail(r *Remote, from string, to []string, msg []byte) error {
 				ServerName:         c.serverName,
 				InsecureSkipVerify: r.SkipVerify,
 			}
+			// Load client certificate on-demand, just before use
+			if r.ClientCertPath != "" && r.ClientKeyPath != "" {
+				cert, err := tls.LoadX509KeyPair(r.ClientCertPath, r.ClientKeyPath)
+				if err != nil {
+					return err
+				}
+				config.Certificates = []tls.Certificate{cert}
+			}
 			if testHookStartTLS != nil {
 				testHookStartTLS(config)
 			}

smtprelay.ini

@@ -13,6 +13,11 @@
 ; Log level: panic, fatal, error, warn, info, debug, trace
 ;log_level = info
 
+; path to alias file
+; alias file format (separated by space):
+; fake@email.tld real@email.tld
+;aliases_file = aliases.txt
+
 ; Hostname for this SMTP server
 ;hostname = localhost.localdomain
 
@@ -30,6 +35,33 @@
 ;local_cert = smtpd.pem
 ;local_key  = smtpd.key
 
+; TLS PROFILE (STARTTLS / TLS listeners)
+; Controls the minimum TLS version and allowed cipher suites for inbound
+; connections when using listen protocols `starttls://` or `tls://`.
+; Profiles follow the Mozilla SSL Configuration Generator guidelines.
+;
+;   default
+;     Go standard library defaults. Tracks improvements as Go updates
+;     its TLS defaults. Recommended for most deployments.
+;
+;   modern
+;     TLS 1.3+ only. Simplest and most secure, but rejects any client
+;     that cannot negotiate TLS 1.3.
+;     Matches Mozilla "modern" configuration.
+;
+;   intermediate
+;     TLS 1.2+. For TLS 1.2 connections only AEAD ciphers (AES-GCM,
+;     ChaCha20-Poly1305) with ECDHE key exchange are allowed,
+;     providing forward secrecy. TLS 1.3 ciphers are always available.
+;     Matches Mozilla "intermediate" configuration.
+;
+;   legacy
+;     TLS 1.0+ with all cipher suites the Go standard library supports,
+;     including insecure ones (RC4, 3DES). Use only when you must
+;     support very old clients that cannot negotiate TLS 1.2.
+;
+;tls_profile=default
+
 ; Enforce encrypted connection on STARTTLS ports before
 ; accepting mails from client.
 ;local_forcetls = false
@@ -114,6 +146,10 @@
 ; Mailjet.com
 ;remotes = starttls://user:pass@in-v3.mailjet.com:587
 
+; Exchange Online (O365) SMTP relay
+; (Change netloc to your own Exchange MX endpoint)
+; remotes = starttls://contoso-com.mail.protection.outlook.com:25
+
 ; Ignore remote host certificates
 ;remotes = starttls://user:pass@server:587?skipVerify
 
@@ -126,5 +162,11 @@
 ; Multiple remotes, space delimited
 ;remotes = smtp://127.0.0.1:1025 starttls://user:pass@smtp.mailgun.org:587
 
+; Client SSL certificate for remote STARTTLS/TLS
+; remote_certificate = /path/to/certificate-chain.pem
+
+; Client SSL private key for remote STARTTLS/TLS
+; remote_key = /path/to/private-key.pem
+
 ; Pipe messages to external command
 ;command = /usr/local/bin/script