Merge remote-tracking branch 'origin/stable' into v2

Refactor TLS fragmenting

.gitattributes

@@ -0,0 +1,3 @@
+# git config merge.theirs.name "Always accept theirs"
+# git config merge.theirs.driver "cp %B %A"
+default.pgo binary merge=theirs

.github/workflows/ci.yaml

@@ -48,6 +48,16 @@ jobs:
       - uses: jdx/mise-action@v3
         name: Install mise
 
+      - name: Cache Go modules and build
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/go/pkg/mod
+            ~/.cache/go-build
+          key: ${{ runner.os }}-go-${{ hashFiles('go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
       - name: Run tests
         run: mise tasks run covtest
 
@@ -69,6 +79,16 @@ jobs:
       - uses: jdx/mise-action@v3
         name: Install mise
 
+      - name: Cache Go modules and build
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/go/pkg/mod
+            ~/.cache/go-build
+          key: ${{ runner.os }}-go-${{ hashFiles('go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
       - name: Run fuzzing
         run: mise tasks run 'test:fuzz:*'
 
@@ -86,13 +106,59 @@ jobs:
       - uses: jdx/mise-action@v3
         name: Install mise
 
+      - name: Cache Go modules and build
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/go/pkg/mod
+            ~/.cache/go-build
+          key: ${{ runner.os }}-go-${{ hashFiles('go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
       - name: Run linter
         run: mise tasks run lint
 
+  artifacts:
+    name: Build release artifacts
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - uses: jdx/mise-action@v3
+        name: Install mise
+
+      - name: Cache Go modules
+        uses: actions/cache@v5
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-gomod-${{ hashFiles('go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-gomod-
+
+      - name: Cache cross-compilation build
+        uses: actions/cache@v5
+        with:
+          path: ~/.cache/go-build
+          key: ${{ runner.os }}-goreleaser-${{ hashFiles('go.sum') }}-${{ hashFiles('**/*.go') }}
+          restore-keys: |
+            ${{ runner.os }}-goreleaser-${{ hashFiles('go.sum') }}-
+            ${{ runner.os }}-goreleaser-
+
+      - name: Run release
+        run: mise tasks run release
+
   docker:
     name: Docker
     runs-on: ubuntu-latest
     timeout-minutes: 20
+    permissions:
+      contents: read
+      packages: write
     steps:
       - name: Checkout
         uses: actions/checkout@v6
@@ -103,9 +169,16 @@ jobs:
         id: meta
         uses: docker/metadata-action@v5
         with:
-          images: nineseconds/mtg
+          images: |
+            nineseconds/mtg
+            ghcr.io/${{ github.repository }}
           tags: |
             type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=raw,value=latest,enable={{is_default_branch}}
+            type=raw,value=master,enable=${{ github.ref == 'refs/heads/master' }}
+            type=raw,value=stable,enable=${{ github.ref == 'refs/heads/stable' }}
 
       - name: Setup QEMU
         uses: docker/setup-qemu-action@v3
@@ -113,14 +186,6 @@ jobs:
       - name: Setup BuildX
         uses: docker/setup-buildx-action@v3
 
-      - name: Setup cache
-        uses: actions/cache@v5
-        with:
-          path: /tmp/buildx-cache
-          key: ${{ runner.os }}-buildx-${{ github.sha }}
-          restore-keys: |
-            ${{ runner.os }}-buildx-
-
       - name: Login to DockerHub
         if: github.event_name != 'pull_request'
         uses: docker/login-action@v3
@@ -128,8 +193,16 @@ jobs:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_PASSWORD }}
 
+      - name: Login to GitHub Container Registry
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
       - name: Build and push
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v6
         with:
           pull: true
           context: .
@@ -137,5 +210,5 @@ jobs:
           push: ${{ github.event_name != 'pull_request' }}
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=local,src=/tmp/buildx-cache
-          cache-to: type=local,dest=/tmp/buildx-cache
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/codeql-analysis.yml

@@ -21,7 +21,7 @@ permissions:
 
 on:
   push:
-    branches: 
+    branches:
       - master
       - stable
   pull_request:
@@ -45,11 +45,13 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v6
+      with:
+        submodules: recursive
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v4
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -60,7 +62,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@v1
+      uses: github/codeql-action/autobuild@v4
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -74,4 +76,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v4

.github/workflows/govulncheck.yml

@@ -0,0 +1,42 @@
+---
+
+name: Vulnerability checks
+
+permissions:
+  actions: read
+  checks: read
+  contents: read
+  deployments: read
+  issues: read
+  discussions: read
+  pull-requests: read
+  repository-projects: read
+  security-events: read
+  statuses: read
+
+on:
+  push:
+  pull_request:
+  schedule: # daily at 10:22 UTC
+    - cron: '22 10 * * *'
+  workflow_dispatch:
+
+jobs:
+  vuln:
+    name: Test vulnerabilities
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v6
+      with:
+        submodules: recursive
+
+    - name: Setup Go
+      uses: actions/setup-go@v6
+      with:
+        go-version-file: go.mod
+        cache: true
+
+    - name: Check for vulnerabilities
+      run: |
+        go run golang.org/x/vuln/cmd/govulncheck@latest ./...

.goreleaser.yml

@@ -10,13 +10,15 @@ before:
     - go generate ./...
 
 builds:
-  - binary: '{{ .ProjectName }}'
+  - id: default
+    binary: '{{ .ProjectName }}'
     goos:
       - darwin
       - freebsd
       - linux
       - netbsd
       - openbsd
+      - windows
     goarch:
       - 386
       - amd64
@@ -34,15 +36,74 @@ builds:
     ignore:
       - goos: darwin
         goarch: 386
+      - goos: darwin
+        goarch: arm
       - goos: freebsd
         goarch: arm64
       - goos: netbsd
         goarch: arm64
       - goos: openbsd
         goarch: arm64
+      - goos: windows
+        goarch: 386
+      - goos: windows
+        goarch: arm
+  - id: mips
+    binary: '{{ .ProjectName }}'
+    goos:
+      - linux
+    goarch:
+      - mips
+      - mipsle
+    gomips:
+      - softfloat
+    env:
+      - CGO_ENABLED=0
+    flags:
+      - -trimpath
+      - -mod=readonly
+    ldflags: -s -w -X main.version={{ .Version }}
+  - id: arm64-v9
+    binary: '{{ .ProjectName }}'
+    goos:
+      - darwin
+      - linux
+    goarch:
+      - arm64
+    goarm64:
+      - v9.0
+    env:
+      - CGO_ENABLED=0
+    flags:
+      - -trimpath
+      - -mod=readonly
+    ldflags: -s -w -X main.version={{ .Version }}
+  - id: amd64-v3
+    binary: '{{ .ProjectName }}'
+    goos:
+      - darwin
+      - freebsd
+      - linux
+      - netbsd
+      - openbsd
+      - windows
+    goarch:
+      - amd64
+    goamd64:
+      - v3
+    env:
+      - CGO_ENABLED=0
+    flags:
+      - -trimpath
+      - -mod=readonly
+    ldflags: -s -w -X main.version={{ .Version }}
 
 archives:
-  - name_template: '{{ .ProjectName }}-{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}'
+  - id: default
+    ids:
+      - default
+      - mips
+    name_template: '{{ .ProjectName }}-{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}'
     formats:
       - tar.gz
     wrap_in_directory: true
@@ -54,6 +115,26 @@ archives:
       - LICENSE
       - README.md
       - SECURITY.md
+      - BEST_PRACTICES.md
+      - example.config.toml
+  - id: optimized
+    ids:
+      - arm64-v9
+      - amd64-v3
+    name_template: '{{ .ProjectName }}-{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm64 }}-{{ .Arm64 }}{{ end }}{{ if .Amd64 }}-{{ .Amd64 }}{{ end }}'
+    formats:
+      - tar.gz
+    wrap_in_directory: true
+    format_overrides:
+      - goos: windows
+        formats:
+          - zip
+    files:
+      - LICENSE
+      - README.md
+      - SECURITY.md
+      - BEST_PRACTICES.md
+      - example.config.toml
 
 gomod:
   proxy: true

.mise.toml

@@ -1,5 +1,11 @@
 [tools]
+"go:golang.org/x/pkgsite/cmd/pkgsite" = "latest"
+"go:golang.org/x/tools/gopls" = "latest"
+"go:golang.org/x/vuln/cmd/govulncheck" = "latest"
+"go:mvdan.cc/gofumpt" = "latest"
 go = "latest"
+golangci-lint = "latest"
+goreleaser = "latest"
 
 [vars]
 fuzzflags = "-fuzztime=120s"
@@ -10,25 +16,34 @@ sources = ["**/*.go", "go.mod", "go.sum"]
 outputs = ["mtg"]
 run = "go build"
 
+[tasks."build:prof"]
+description = "Build binary with profiling enabled"
+sources = ["**/*.go", "go.mod", "go.sum"]
+outputs = ["mtg"]
+run = "go build -tags prof"
+
 [tasks.update]
 description = "Update dependencies"
 run = [
     "go get -u",
-    "go mod tidy -go=1.25"
+    "go mod tidy -go=1.26"
 ]
 
 [tasks.lint]
 description = "Run linter"
-tools.golangci-lint = "latest"
 run = "golangci-lint run"
 
+[tasks.vuln]
+description = "Test for vulnerabilities"
+run = "govulncheck ./..."
+
 [tasks.test]
 description = "Run tests"
-run = "go test -v ./..."
+run = "go test -v -race ./..."
 
 [tasks.covtest]
 description = "Run tests with code coverage"
-run = "go test -coverprofile=coverage.txt -covermode=atomic -parallel 2 -race -v ./..."
+run = "go test -coverprofile=coverage.txt -covermode=atomic -count=2 -race -v ./..."
 
 [tasks.test-all]
 description = "Run all tests"
@@ -39,23 +54,15 @@ depends = [
 
 [tasks."test:fuzz:client-hello"]
 description = "Run fuzzy test for ClientHello"
-run = "go test -v {{ vars.fuzzflags }} -fuzz=FuzzClientHello ./mtglib/internal/faketls"
+run = "go test -v {{ vars.fuzzflags }} -fuzz=FuzzReadClientHello ./mtglib/internal/tls/fake"
 
 [tasks."test:fuzz:client-handshake"]
 description = "Run fuzzy test for ClientHandshake"
-run = "go test -v {{ vars.fuzzflags }} -fuzz=FuzzClientHandshake ./mtglib/internal/obfuscated2"
+run = "go test -v {{ vars.fuzzflags }} -fuzz=FuzzClientServerHandshake ./mtglib/internal/obfuscation"
 
-[tasks."test:fuzz:server-generate-handshake-frame"]
-description = "Run fuzzy test for ServerGenerateHandshakeFrame"
-run = "go test -v {{ vars.fuzzflags }} -fuzz=FuzzServerGenerateHandshakeFrame ./mtglib/internal/obfuscated2"
-
-[tasks."test:fuzz:server-receive"]
-description = "Run fuzzy test for ServerReceive"
-run = "go test -v {{ vars.fuzzflags }} -fuzz=FuzzServerReceive ./mtglib/internal/obfuscated2"
-
-[tasks."test:fuzz:server-send"]
-description = "Run fuzzy test for ServerSend"
-run = "go test -v {{ vars.fuzzflags }} -fuzz=FuzzServerSend ./mtglib/internal/obfuscated2"
+[tasks."test:fuzz:server-handshake-frame"]
+description = "Run fuzzy test for GenerateHandshakeFrame"
+run = "go test -v {{ vars.fuzzflags }} -fuzz=FuzzGenerateHandshakeFrame ./mtglib/internal/obfuscation"
 
 [tasks.static]
 description = "Build static binary"
@@ -75,7 +82,6 @@ go build \
 
 [tasks.release]
 description = "Create release tarballs"
-tools.goreleaser = "latest"
 sources = ["**/*.go", "go.mod", "go.sum", ".goreleaser.yml"]
 run = [
     "goreleaser --snapshot --clean",
@@ -90,11 +96,9 @@ run = "docker buildx build --pull -t mtg ."
 
 [tasks.docs]
 description = "Run doc server"
-tools."go:golang.org/x/pkgsite/cmd/pkgsite" = "latest"
 run = "pkgsite -http 0.0.0.0:10000"
 
 [tasks.fmt]
 description = "Reformat source code"
-tools.gofumpt = "latest"
 sources = ["**/*.go"]
 run = "gofumpt -w --extra ."

BEST_PRACTICES.md

@@ -0,0 +1,55 @@
+# Best practices
+
+This is unfortunate, but since 2018 many things were changed. Most of them
+became way worse. Previous iterations of censorship systems were very dumb,
+DPI were primitive and filtered very obvious things. Nowadays they are
+way more intelligent and it is very naive to treat them frivolously.
+
+In 2026 is not enough to pretend that your mtg installation is a Microsoft
+website that sits in Amsterdam Digital Ocean location. Now your installation
+has to be a website that is mtg in disguise. Yes, it requires a bit more effort
+but this effort is probably less than rotating proxies each other day.
+
+mtproto traffic, even with FakeTLS, has its specifics that are probably
+very well known by DPI systems. These specifics are not something unique but
+could mark an IP address as suspicious. Now let's think:
+
+1. You have a proxy in Amsterdam Digital Ocean that tells it is microsoft.com
+   how hard could it be to find out that this is probably fake? 1 or probably 2
+   DNS queries for `microsoft.com`? In case of some CDN, there are ECS-powered
+   resolvers that are very capable to return results from POV of some subnets.
+   If censor sees no relevant results, will they be afraid to block IP?
+2. You have a proxy in Amsterdam Digital Ocean that tells it is a website from
+   the same public subnet. But not the same. Would it be hard to make these DNS
+   queries and ban IP?
+
+The correct way of having this proxy is following:
+
+1. Register a domain name
+2. Get some VPS, probably in your domestic location
+3. Set that domain name from a step 1 to IP address of that VPS
+4. Generate a couple of HTML pages by LLMs or even copy them from elsewhere
+5. Set some webserver and issue TLS certificates with Let's Encrypt or any other
+   name
+6. Set mtg before this webserver.
+7. Use sing-box or anything like that to provide local socks5 interface and
+   have VPNized uplinks
+8. Set up mtg to use socks5 from a 7 step.
+
+In that case you will get a match of DNS and SNI in requests. As a side effect,
+your proxy will work with XTLS and its friends: XTLS in sniff mode ignores
+IP address a client wants to connect to. Instead, it reads SNI and connect
+to resolved address: a clever idea if user does not have a trustworthy DNS
+set up.
+
+Yes, this is much longer that usual technique, and requires more effort. But
+this is could probably be very well automated to some reasonable extent.
+
+Unfortunately, this is a best practice right now.
+
+Do not also forget about other implementation, like
+[telemt](https://github.com/telemt/telemt). Try everything. Use VPNs. It does
+not really matter which project you are going to use as long it helps you to
+stay connected.
+
+_March 2026._

Dockerfile

@@ -5,17 +5,35 @@ FROM golang:1.26-alpine AS build
 
 ENV CGO_ENABLED=0
 
+# this is done for backward compatibility: before that we mounted a config
+# into /config.toml. Some application allow mounting directories only,
+# so it makes problems. So, instead we are going to do 2 steps:
+#  1. Create /config/config.toml as a symlink to /config.toml
+#  2. Force /mtg to use /config/config.toml
+#
+# it helps in both ways: users with directories could use /config directory
+# and overlap a symlink by their bind mount. Old users could continue using
+# /config.toml as a real config.
 RUN set -x \
-  && apk --no-cache --update add \
-    bash \
-    ca-certificates \
-    git
+  && mkdir -p /config \
+  && ln -sv /config.toml /config/config.toml
 
-COPY . /app
+RUN --mount=type=cache,target=/var/cache/apk \
+    set -x \
+    && apk --update add \
+      bash \
+      ca-certificates \
+      git
+
+COPY go.mod go.sum /app/
 WORKDIR /app
 
+RUN go mod download
+
+COPY . /app
+
 RUN set -x \
-  && version="$(git describe --exact-match HEAD 2>/dev/null || git describe --tags --always)" \
+  && version="$(git describe --exact-match HEAD 2>/dev/null || git describe --tags --always 2>/dev/null || echo dev)" \
   && go build \
       -trimpath \
       -mod=readonly \
@@ -30,8 +48,9 @@ RUN set -x \
 FROM scratch
 
 ENTRYPOINT ["/mtg"]
-CMD ["run", "/config.toml"]
+CMD ["run", "/config/config.toml"]
 
 COPY --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
 COPY --from=build /app/mtg /mtg
 COPY --from=build /app/example.config.toml /config.toml
+COPY --from=build /config /config

README.md

@@ -10,6 +10,17 @@ Highly-opinionated (ex-bullshit-free) MTPROTO proxy for
 **If you use v1.0 or upgrade broke you proxy, please read the chapter
 [Version 2](#version-2)**
 
+If you want to have a proxy that _supports adtag_ (possibility to promote a
+channel with a special Telegram bot), I recommend to use
+[telemt](https://github.com/telemt/telemt) project. v1 of mtg supports it
+but I do not see any reasonable point of using it: adtag requires communication
+via a fragile set of middle proxies, requires complex setup that must expose
+a public IPs, has lower bandwidth and latency.
+
+mtg idea is simple: minimal unbloated proxy that can handle a reasonable scale
+~10-20k simultaneous connections, has no user management, but ticks all
+checkboxes related to its main intent: provide a way to use Telegram.
+
 ## Rationale
 
 There are several available proxies for Telegram MTPROTO available. Here
@@ -18,6 +29,9 @@ are the most notable:
 * [Official](https://github.com/TelegramMessenger/MTProxy)
 * [Python](https://github.com/alexbers/mtprotoproxy)
 * [Erlang](https://github.com/seriyps/mtproto_proxy)
+* [Teleproxy (C)](https://github.com/teleproxy/teleproxy)
+* [mtproto.zig (Zig)](https://github.com/sleep3r/mtproto.zig)
+* [Telemt (Rust)](https://github.com/telemt/telemt)
 
 You can use any of these. They work great and all implementations have
 feature parity now. This includes support of adtag, replay attack
@@ -26,6 +40,33 @@ goal: to give a possibility to connect to Telegram in a restricted,
 censored environment. But it does it slightly differently in details
 that probably matter.
 
+* **Domain fronting**
+
+  For years mtg supports domain fronting. This technique means that it fallbacks
+  to accessing a real website in case if request fails. It could fail by many
+  reasons: anti-replay protection, accidental access to the webserver or
+  stale request. Anyway, if mtg rejects this request, it does not break a
+  connection. It connects to the websites and replicates everything that client
+  has sent, and simply proxies it back as is. Users will see a response from
+  the real website, _byte-to-byte identical_ to the response of the real netloc.
+
+* **Doppelganger**
+
+  mtg also is a doppelganger of the website it fronts. Sure, with domain fronting
+  users will see replies of the real website in case if something will go wrong.
+  But what about such cases when _everything is fine_?
+
+  In that case mtg mimics TLS connection statistical characteristics as close as
+  possible. Different application have different statistics of their patterns.
+  Big CDN steadily pumping the data, small websites burst with short easily
+  compressiable chunks of traffic.
+
+  mtg artificially emulates those delays to be statistically indistinguishable
+  from the real website even if it covers connection of the very specific app.
+  It also follows 2 most common patterns of traffic chunking, so censors
+  will have to put more resources to find out that we have Telegram here
+  but not a hookah webshop served by nginx.
+
 * **Resource-efficient**
 
   It has to be resource-efficient. It does not mean that you will see
@@ -40,12 +81,21 @@ that probably matter.
   way of doing business I suppose. I think the only viable way is to
   have a proxy that can be restored anywhere easily.
 
+* **Supports proxy protocol v1/v2**
+
+  This makes integration with loadbalancers like HAProxy and ELB a first class
+  citizen by supporting their
+  [commuication protocols](https://www.haproxy.org/download/2.3/doc/proxy-protocol.txt).
+
 * **A single secret**
 
   I think that multiple secrets solve no problems and just complex
   software. I also believe that in the case of throwout proxies, this
   the feature is a useless luxury.
 
+  This is very controversial topic. Please read [rationale (in russian)](https://github.com/9seconds/mtg/issues/376#issuecomment-4118726699)
+  and use [mtg-multi](https://github.com/dolonet/mtg-multi) fork if you are disagree with.
+
 * **No adtag support**
 
   Please read [Version 2](#version-2) chapter.
@@ -75,6 +125,8 @@ that probably matter.
   software (written in Golang) with a minimum effort + you can replace
   some parts with those you want.
 
+Please also to read about [best practices](https://github.com/9seconds/mtg/blob/master/BEST_PRACTICES.md).
+
 ### Version 2
 
 If you use version 1.x before, you are probably noticed some major
@@ -162,6 +214,12 @@ This project has several main branches
 
 ## Getting started
 
+### Download mise
+
+mtg uses [mise](https://mise.jdx.dev/) to maintain its development
+dependencies + replaces a make for building things. Please
+[install](https://mise.jdx.dev/getting-started.html) it first.
+
 ### Download a tool
 
 #### Download binaries
@@ -198,13 +256,14 @@ go install github.com/9seconds/mtg/v2@latest
 ```console
 git clone https://github.com/9seconds/mtg.git
 cd mtg
-make static
+mise install
+mise tasks run build
 ```
 
 or for the docker image:
 
 ```console
-make docker
+mise tasks run image
 ```
 
 ### Generate secret
@@ -247,6 +306,38 @@ For example, you've bought a VPS from [Digital
 Ocean](https://www.digitalocean.com/). Then it might be a good idea to
 generate a secret for _digitalocean.com_ then.
 
+### Check configuration
+
+There is a special command for secret verification:
+
+```
+$ mtg doctor /path/to/my/config.toml
+Deprecated options
+  ✅ All good
+Time skewness
+  ✅ Time drift is -607.048µs, but tolerate-time-skewness is 5s
+Validate native network connectivity
+  ✅ DC 1
+  ✅ DC 2
+  ✅ DC 3
+  ✅ DC 4
+  ✅ DC 5
+  ✅ DC 203
+Validate network connectivity with proxy socks5://127.0.0.1:1080
+  ✅ DC 1
+  ✅ DC 2
+  ✅ DC 3
+  ✅ DC 4
+  ✅ DC 5
+  ✅ DC 203
+Validate fronting domain connectivity
+  ✅ xx.xx.xx.xx:yyy is reachable
+Validate SNI-DNS match
+  ✅ IP address xx.xx.xx.xx matches secret hostname <REDACTED>
+```
+
+It aims to find out possible inconsistencies and problems with your
+configuration. It makes sense to run it before executing any relevant commands.
 
 ### Simple run mode
 
@@ -275,7 +366,7 @@ Flags:
   -b, --tcp-buffer="4KB"               Size of TCP buffer to use.
   -i, --prefer-ip="prefer-ipv6"        IP preference. By default we prefer IPv6 with fallback to IPv4.
   -p, --domain-fronting-port=443       A port to access for domain fronting.
-  -n, --doh-ip=9.9.9.9                 IP address of DNS-over-HTTP to use.
+  -n, --doh-ip=1.1.1.1                 IP address of DNS-over-HTTP to use.
   -t, --timeout=10s                    Network timeout to use
   -a, --antireplay-cache-size="1MB"    A size of anti-replay cache to use.
 ```
@@ -326,6 +417,7 @@ ExecStart=/usr/local/bin/mtg run /etc/mtg.toml
 Restart=always
 RestartSec=3
 DynamicUser=true
+LimitNOFILE=65536
 AmbientCapabilities=CAP_NET_BIND_SERVICE
 
 [Install]
@@ -373,6 +465,55 @@ or if you are using docker:
 $ docker exec mtg-proxy /mtg access /config.toml
 ```
 
+## Doppelganger
+
+mtg can mimic real websites, please take a look at relevant section in example
+config file.
+
+mtg comes with some very good precollected statistics coming from
+[ok.ru](https://ok.ru/). It does not mean that you have to cover yourself
+by pretending that mtg is _ok.ru_. **Do not do that: ok.ru comes from very specific
+ASNs, but not from VPS providers you are going to use.** What I want to say
+is that defaults are very good enough to use as is because ok.ru for public
+pages has a very generic profile of TLS packets delay.
+
+But for better results it is recommended to teach mtg about the website you
+will use as a domain front. In order to do that, you need to specify URLs
+from this website. Just go to it, open WebDeveloper console and pick up
+random URLs. For better results they have to be **from the same domain name
+you are going to use as a disguise** but serve light and heavy content: pages,
+images etc. Do not use many, 2-3 will probably work.
+
+mtg will crawl these pages periodically, accumulating statistics and
+using it as you go.
+
+```toml
+[defense.doppelganger]
+urls = [
+  "https://lalala.com/index.html",
+  "https://lalala.com/contacts.html",
+]
+```
+
+This is not very necessary. Keep in mind these rules:
+
+1. If you are not sure what is this all about, do nothing. Defaults are good.
+2. All URLs must be HTTPS
+3. All URLs should be from the same domain name (but this is not a rule)
+4. Do not use a lot of pages. Use _different_ pages. mtg will start using this
+   statistics when it will accumulate enough anyway.
+5. These URLs should be directly accessible from mtg without proxies whatsoever
+6. Do not create huge raids. mtg will repeatedly crawl in raids, making N repeats.
+   Do not use high N, you do not want to be noticeable.
+7. It makes no sense to have small delay between raids. Usually webservers
+   do not update their TLS settings each hour.
+8. If you have some specific knowledge if webserver is using
+   [TLS Dynamic Record Sizing](https://blog.cloudflare.com/optimizing-tls-over-tcp-to-reduce-latency/), you
+   can use a very specific setting. This are Cloudflare, Go standard webservers,
+   [caddy](https://caddyserver.com/) and [H2O](https://h2o.examp1e.net/). If so,
+   you can enable `drs` setting.
+9. **If you are not sure, touch nothing!**
+
 ## Metrics
 
 Out of the box, mtg works with

antireplay/stable_bloom_filter_test.go

@@ -12,7 +12,7 @@ type StableBloomFilterTestSuite struct {
 }
 
 func (suite *StableBloomFilterTestSuite) TestOp() {
-	filter := antireplay.NewStableBloomFilter(500, 0.001)
+	filter := antireplay.NewStableBloomFilter(100000, 0.001)
 
 	suite.False(filter.SeenBefore([]byte{1, 2, 3}))
 	suite.False(filter.SeenBefore([]byte{4, 5, 6}))

essentials/addresses.go

@@ -0,0 +1,30 @@
+package essentials
+
+// TelegramCoreAddresses are publicly known addresses of Telegram core network.
+var TelegramCoreAddresses = map[int][]string{
+	1: {
+		"149.154.175.50:443",
+		"[2001:b28:f23d:f001::a]:443",
+	},
+	2: {
+		"149.154.167.51:443",
+		"95.161.76.100:443",
+		"[2001:67c:04e8:f002::a]:443",
+	},
+	3: {
+		"149.154.175.100:443",
+		"[2001:b28:f23d:f003::a]:443",
+	},
+	4: {
+		"149.154.167.91:443",
+		"[2001:67c:04e8:f004::a]:443",
+	},
+	5: {
+		"149.154.171.5:443",
+		"[2001:b28:f23f:f005::a]:443",
+	},
+	203: {
+		"91.105.192.100:443",
+		"[2a0a:f280:0203:000a:5000:0000:0000:0100]:443",
+	},
+}

essentials/conns.go

@@ -24,3 +24,28 @@ type Conn interface {
 	CloseableReader
 	CloseableWriter
 }
+
+type netConnWrapper struct {
+	net.Conn
+}
+
+func (n netConnWrapper) CloseRead() error {
+	if conn, ok := n.Conn.(CloseableReader); ok {
+		return conn.CloseRead()
+	}
+
+	return n.Close()
+}
+
+func (n netConnWrapper) CloseWrite() error {
+	if conn, ok := n.Conn.(CloseableWriter); ok {
+		return conn.CloseWrite()
+	}
+
+	return n.Close()
+}
+
+// WrapConn wraps a generic [net.Conn] into Conn.
+func WrapNetConn(conn net.Conn) Conn {
+	return netConnWrapper{conn}
+}

events/event_stream.go

@@ -2,7 +2,7 @@ package events
 
 import (
 	"context"
-	"math/rand"
+	"math/rand/v2"
 	"runtime"
 
 	"github.com/9seconds/mtg/v2/mtglib"
@@ -38,7 +38,7 @@ func (e EventStream) Send(ctx context.Context, evt mtglib.Event) {
 	select {
 	case <-ctx.Done():
 	case <-e.ctx.Done():
-	case e.chans[int(chanNo)%len(e.chans)] <- evt:
+	case e.chans[chanNo%uint32(len(e.chans))] <- evt:
 	}
 }
 
@@ -64,7 +64,7 @@ func NewEventStream(observerFactories []ObserverFactory) EventStream {
 		chans:     make([]chan mtglib.Event, runtime.NumCPU()),
 	}
 
-	for i := 0; i < runtime.NumCPU(); i++ {
+	for i := range runtime.NumCPU() {
 		rv.chans[i] = make(chan mtglib.Event, 1)
 
 		if len(observerFactories) == 1 {

events/multi_observer.go

@@ -12,14 +12,11 @@ type multiObserver struct {
 
 func (m multiObserver) EventStart(evt mtglib.EventStart) {
 	wg := &sync.WaitGroup{}
-	wg.Add(len(m.observers))
 
 	for _, v := range m.observers {
-		go func(obs Observer) {
-			defer wg.Done()
-
-			obs.EventStart(evt)
-		}(v)
+		wg.Go(func() {
+			v.EventStart(evt)
+		})
 	}
 
 	wg.Wait()
@@ -27,14 +24,11 @@ func (m multiObserver) EventStart(evt mtglib.EventStart) {
 
 func (m multiObserver) EventConnectedToDC(evt mtglib.EventConnectedToDC) {
 	wg := &sync.WaitGroup{}
-	wg.Add(len(m.observers))
 
 	for _, v := range m.observers {
-		go func(obs Observer) {
-			defer wg.Done()
-
-			obs.EventConnectedToDC(evt)
-		}(v)
+		wg.Go(func() {
+			v.EventConnectedToDC(evt)
+		})
 	}
 
 	wg.Wait()
@@ -42,14 +36,11 @@ func (m multiObserver) EventConnectedToDC(evt mtglib.EventConnectedToDC) {
 
 func (m multiObserver) EventDomainFronting(evt mtglib.EventDomainFronting) {
 	wg := &sync.WaitGroup{}
-	wg.Add(len(m.observers))
 
 	for _, v := range m.observers {
-		go func(obs Observer) {
-			defer wg.Done()
-
-			obs.EventDomainFronting(evt)
-		}(v)
+		wg.Go(func() {
+			v.EventDomainFronting(evt)
+		})
 	}
 
 	wg.Wait()
@@ -57,14 +48,11 @@ func (m multiObserver) EventDomainFronting(evt mtglib.EventDomainFronting) {
 
 func (m multiObserver) EventTraffic(evt mtglib.EventTraffic) {
 	wg := &sync.WaitGroup{}
-	wg.Add(len(m.observers))
 
 	for _, v := range m.observers {
-		go func(obs Observer) {
-			defer wg.Done()
-
-			obs.EventTraffic(evt)
-		}(v)
+		wg.Go(func() {
+			v.EventTraffic(evt)
+		})
 	}
 
 	wg.Wait()
@@ -72,14 +60,11 @@ func (m multiObserver) EventTraffic(evt mtglib.EventTraffic) {
 
 func (m multiObserver) EventFinish(evt mtglib.EventFinish) {
 	wg := &sync.WaitGroup{}
-	wg.Add(len(m.observers))
 
 	for _, v := range m.observers {
-		go func(obs Observer) {
-			defer wg.Done()
-
-			obs.EventFinish(evt)
-		}(v)
+		wg.Go(func() {
+			v.EventFinish(evt)
+		})
 	}
 
 	wg.Wait()
@@ -87,14 +72,11 @@ func (m multiObserver) EventFinish(evt mtglib.EventFinish) {
 
 func (m multiObserver) EventConcurrencyLimited(evt mtglib.EventConcurrencyLimited) {
 	wg := &sync.WaitGroup{}
-	wg.Add(len(m.observers))
 
 	for _, v := range m.observers {
-		go func(obs Observer) {
-			defer wg.Done()
-
-			obs.EventConcurrencyLimited(evt)
-		}(v)
+		wg.Go(func() {
+			v.EventConcurrencyLimited(evt)
+		})
 	}
 
 	wg.Wait()
@@ -102,14 +84,11 @@ func (m multiObserver) EventConcurrencyLimited(evt mtglib.EventConcurrencyLimite
 
 func (m multiObserver) EventIPBlocklisted(evt mtglib.EventIPBlocklisted) {
 	wg := &sync.WaitGroup{}
-	wg.Add(len(m.observers))
 
 	for _, v := range m.observers {
-		go func(obs Observer) {
-			defer wg.Done()
-
-			obs.EventIPBlocklisted(evt)
-		}(v)
+		wg.Go(func() {
+			v.EventIPBlocklisted(evt)
+		})
 	}
 
 	wg.Wait()
@@ -117,14 +96,11 @@ func (m multiObserver) EventIPBlocklisted(evt mtglib.EventIPBlocklisted) {
 
 func (m multiObserver) EventReplayAttack(evt mtglib.EventReplayAttack) {
 	wg := &sync.WaitGroup{}
-	wg.Add(len(m.observers))
 
 	for _, v := range m.observers {
-		go func(obs Observer) {
-			defer wg.Done()
-
-			obs.EventReplayAttack(evt)
-		}(v)
+		wg.Go(func() {
+			v.EventReplayAttack(evt)
+		})
 	}
 
 	wg.Wait()
@@ -132,14 +108,11 @@ func (m multiObserver) EventReplayAttack(evt mtglib.EventReplayAttack) {
 
 func (m multiObserver) EventIPListSize(evt mtglib.EventIPListSize) {
 	wg := &sync.WaitGroup{}
-	wg.Add(len(m.observers))
 
 	for _, v := range m.observers {
-		go func(obs Observer) {
-			defer wg.Done()
-
-			obs.EventIPListSize(evt)
-		}(v)
+		wg.Go(func() {
+			v.EventIPListSize(evt)
+		})
 	}
 
 	wg.Wait()

example.config.toml

@@ -23,17 +23,19 @@ secret = "ee367a189aee18fa31c190054efd4a8e9573746f726167652e676f6f676c6561706973
 # Host:port pair to run proxy on.
 bind-to = "0.0.0.0:3128"
 
+# This defines what types of traffic mtg listens to. If you are not sure,
+# then definitely keep it disable. Enable it only and only if incoming traffic
+# is coming from some sort of load-balancer like HAProxy or ELB.
+# https://www.haproxy.org/download/2.3/doc/proxy-protocol.txt
+#
+# mtg uses a library that supports v1 and v2 versions of ProxyProtocol.
+# default value is false.
+# proxy-protocol-listener = false
+
 # Defines how many concurrent connections are allowed to this proxy.
 # All other incoming connections are going to be dropped.
 concurrency = 8192
 
-# A size of user-space buffer for TCP to use. Since we do 2 connections,
-# then we have tcp-buffer * (4 + 2) per each connection: read/write for
-# each connection + 2 copy buffers to pump the data between sockets.
-#
-# Deprecated: this setting is no longer makes any effect.
-# tcp-buffer = "4kb"
-
 # Sometimes you want to enforce mtg to use some types of
 # IP connectivity to Telegram. We have 4 modes:
 #   - prefer-ipv6:
@@ -46,9 +48,42 @@ concurrency = 8192
 #     Only ipv4 connectivity is used
 prefer-ip = "prefer-ipv6"
 
+# Public IP addresses of this server. Used by 'mtg access' to generate
+# proxy links and by 'mtg doctor' to validate SNI-DNS match.
+# If not set, mtg tries to detect them automatically via ifconfig.co.
+# Set these if ifconfig.co is unreachable from your server.
+# public-ipv4 = "1.2.3.4"
+# public-ipv6 = "2001:db8::1"
+
+# If this setting is set, then mtg will try to get proxy updates from Telegram
+# Usually this is completely fine to have it disabled, because mtg has a list
+# of some core proxies hardcoded.
+auto-update = false
+
 # FakeTLS uses domain fronting protection. So it needs to know a port to
 # access.
-domain-fronting-port = 443
+#
+# Deprecated: use [domain-fronting] configuration block. If relevant option
+# is defined there, this one would be ignored.
+# domain-fronting-port = 443
+
+# By default, mtg resolves the fronting hostname (from the secret) via DNS
+# to establish a TCP connection. If DNS resolution of that hostname is blocked,
+# you can specify an IP address to connect to directly. The hostname is still
+# used for SNI in the TLS handshake.
+#
+# default value is not set (DNS resolution is used).
+#
+# Deprecated: use [domain-fronting] configuration block. If relevant option
+# is defined there, this one would be ignored.
+# domain-fronting-ip = "10.0.0.10"
+
+# This makes a communication between both fronting website and mtg to use
+# proxy protocol.
+#
+# Deprecated: use [domain-fronting] configuration block. If relevant option
+# is defined there, this one would be ignored.
+# domain-fronting-proxy-protocol = false
 
 # FakeTLS can compare timestamps to prevent probes. Each message has
 # encrypted timestamp. So, mtg can compare this timestamp and decide if
@@ -71,6 +106,27 @@ tolerate-time-skewness = "5s"
 # Otherwise, chose a new DC.
 allow-fallback-on-unknown-dc = false
 
+# This section is relevant to communication with fronting domain. Usually
+# you do not need to setup anything here but there are plenty of cases, especially
+# if you put mtg behind load balancer, when some specific configuration is
+# required.
+[domain-fronting]
+# By default, mtg resolves the fronting hostname (from the secret) via DNS
+# to establish a TCP connection. If DNS resolution of that hostname is blocked,
+# you can specify an IP address to connect to directly. The hostname is still
+# used for SNI in the TLS handshake.
+#
+# default value is not set (DNS resolution is used).
+# ip = "10.10.10.11"
+
+# FakeTLS uses domain fronting protection. So it needs to know a port to
+# access. Default value is 443
+# port = 443
+
+# This makes a communication between both fronting website and mtg to use
+# proxy protocol.
+# proxy-protocol = false
+
 # network defines different network-related settings
 [network]
 # please be aware that mtg needs to do some external requests. For
@@ -84,8 +140,43 @@ allow-fallback-on-unknown-dc = false
 # resolver of the operating system and uses DOH instead. This is a host
 # it has to access.
 #
-# By default we use Quad9.
-doh-ip = "9.9.9.9"
+# By default we use Cloudflare.
+#
+# DEPRECATED option:
+#  If dns option is specified, it will be used instead. No default is defined
+#  anymore. But if you set this option, this is literally the same providing
+#  https:// URL to `dns`.
+#
+#  In other words:
+#
+#    doh-ip = "1.1.1.1"
+#
+# is literally the same as
+#
+#    dns = "https://1.1.1.1"
+# doh-ip = "1.1.1.1"
+
+# Starting from mtg v2.1.12 we have changed a configuration for DNS. Now it
+# supports DNS-over-HTTPS, DNS-over-TLS, custom UDP resolver and system
+# resolver.
+#
+# Here is how to define DNS-over-HTTPS:
+#  - https://1.1.1.1
+#  - https://1.1.1.1/dns-query
+#  - https://cloudflare-dns.com/dns-query
+#  - https://cloudflare-dns.com
+#
+# Here is how to define DNS-over-TLS:
+#  - tls://1.1.1.1
+#  - tls://cloudflare-dns.com
+#
+# Here is how to define a custom UDP resolver (we support only IPs here)
+#  - 1.1.1.1
+#  - udp://1.1.1.1
+#
+# If you set it to empty string, default resolver will be used.
+# But please comment out doh-ip
+dns = "https://1.1.1.1"
 
 # mtg can work via proxies (for now, we support only socks5). Proxy
 # configuration is done via list. So, you can specify many proxies
@@ -100,25 +191,13 @@ doh-ip = "9.9.9.9"
 #
 # Proxy configuration is done via ordinary URI schema:
 #
-#     socks5://user:password@host:port?open_threshold=5&half_open_timeout=1m&reset_failures_timeout=10s
+#     socks5://user:password@host:port
 #
 # Only socks5 proxy is used. user/password is optional. As you can
 # see, you can specify some parameters in GET query. These parameters
 # configure circuit breaker.
-#
-# open_threshold means a number of errors which should happen so we stop
-# use a proxy.
-#
-# half_open_timeout means a time period (in Golang duration notation)
-# after which we can retry with this proxy
-#
-# reset_failures_timeout means a time period when we flush out errors
-# when circuit breaker in closed state.
-#
-# Please see https://docs.microsoft.com/en-us/azure/architecture/patterns/circuit-breaker
-# on details about circuit breakers.
 proxies = [
-    # "socks5://user:password@host:port?open_threshold=5&half_open_timeout=1m&reset_failures_timeout=10s"
+    # "socks5://user:password@host:port"
 ]
 
 # network timeouts define different settings for timeouts. tcp timeout
@@ -134,6 +213,66 @@ tcp = "5s"
 http = "10s"
 idle = "1m"
 
+# mtg has to mimic real websites. It does not mean domain fronting, it also
+# means that traffic characteristics should be similar to real world traffic.
+# websites and applications behave differently, their traffic patterns are also
+# different. Applications do bursts of RPC-style messages (or JSON communication,
+# does not really matter), while websites pump heavy content in HTTP2 streams
+#
+# It means that statistically there is a different between traffic shape:
+# delays between packets are also different.
+# In order to avoid censorship detection based on these patterns, there is a
+# mtg subsystem called "Doppelganger" that aims to mimic website statistics
+# as close as it could.
+#
+# Delays between TLS packets are not constant. There are many factors
+# that come in play. Application should generate some response, it could
+# send some headers first and stream content with chunked encoding. So
+# some first packets could come as soon as possible, with some delays
+# after first ones. Such phenomenon is described by different statistic
+# distribution. There are 2 distribution that describe it: lognormal
+# distribution and Weibul distribution. Lognormal is all about steady streams
+# of heavy content like a video. Weibul is great about short bursts like
+# user who requested a static page an a couple of images.
+[defense.doppelganger]
+# This is a list of URLs that would be crawled by mtg to approximate delay
+# statistics. They MUST be HTTPS urls.
+#
+# You can come to the website and collect different URLs, with light and
+# heavy content. We recommend to search for CDNs.
+urls = [
+    # "https://st-ok.cdn-vk.ru/res/react/vendor/clsx-2.1.1-amd.js"
+]
+# A collection is done in raids. Each raid makes this number of requests to
+# each URL in this list. Do not use a huge number, 10 is probably ok.
+repeats-per-raid = 10
+# This is a duration between each raid. It makes no sense to have a small number
+# here as you would start to make a noticeable activity. Usually traffic patterns
+# do not change a lot, so do not expect different results if you request
+# each 10 minutes.
+raid-each = "6h"
+# This enables dynamic tls record sizing.
+#
+# Some modern stacks and platforms start to use the technique that is called
+# DRS. They start with small TLS packets and ramp up eventually. First packets
+# are usually about MTU size, after that we get 4k and eventually max size.
+# This is done with a good intention: to minimize a time to the first byte,
+# so application could start doing something with the data right after first
+# RTT.
+#
+# Apparently, about 90% of application do not employ this technique, they use
+# max size always: nginx, apache, java stuff. But Golang tools, angie and
+# some specific patches activate this technique.
+#
+# In order to mimic a real website we need to know something about software
+# it uses. Usually nobody cares: openssl does 16384, Python does it, nginx
+# does it. So this setting is disabled by default.
+#
+#      https://blog.cloudflare.com/optimizing-tls-over-tcp-to-reduce-latency/
+#      https://aws.github.io/s2n-tls/usage-guide/ch08-record-sizes.html
+#      https://github.com/cloudflare/sslconfig/blob/master/patches/nginx__dynamic_tls_records.patch
+drs = false
+
 # Some countries do active probing on Telegram connections. This technique
 # allows to protect from such effort.
 #

go.mod

@@ -1,6 +1,6 @@
 module github.com/9seconds/mtg/v2
 
-go 1.25
+go 1.26
 
 require (
 	github.com/OneOfOne/xxhash v1.2.8
@@ -11,23 +11,27 @@ require (
 	github.com/d4l3k/messagediff v1.2.1 // indirect
 	github.com/jarcoal/httpmock v1.0.8
 	github.com/mccutchen/go-httpbin v1.1.1
-	github.com/panjf2000/ants/v2 v2.11.5
-	github.com/pelletier/go-toml v1.9.5
+	github.com/panjf2000/ants/v2 v2.12.0
 	github.com/prometheus/client_golang v1.23.2
 	github.com/prometheus/common v0.67.5 // indirect
-	github.com/prometheus/procfs v0.19.2 // indirect
-	github.com/rs/zerolog v1.34.0
+	github.com/prometheus/procfs v0.20.1 // indirect
+	github.com/rs/zerolog v1.35.0
 	github.com/smira/go-statsd v1.3.4
 	github.com/stretchr/objx v0.5.2 // indirect
 	github.com/stretchr/testify v1.11.1
 	github.com/tylertreat/BoomFilters v0.0.0-20251117164519-53813c36cc1b
-	golang.org/x/crypto v0.48.0
-	golang.org/x/net v0.49.0 // indirect
-	golang.org/x/sys v0.41.0
+	golang.org/x/crypto v0.49.0
+	golang.org/x/net v0.52.0
+	golang.org/x/sys v0.42.0
 	google.golang.org/protobuf v1.36.11 // indirect
 )
 
 require (
+	github.com/beevik/ntp v1.5.0
+	github.com/ncruces/go-dns v1.3.2
+	github.com/pelletier/go-toml/v2 v2.3.0
+	github.com/pires/go-proxyproto v0.11.0
+	github.com/things-go/go-socks5 v0.1.0
 	github.com/txthinking/socks5 v0.0.0-20251011041537-5c31f201a10e
 	github.com/yl2chen/cidranger v1.0.2
 )
@@ -36,6 +40,7 @@ require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/klauspost/compress v1.18.3 // indirect
 	github.com/kr/text v0.2.0 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
@@ -43,8 +48,10 @@ require (
 	github.com/patrickmn/go-cache v2.1.0+incompatible // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/prometheus/client_model v0.6.2 // indirect
+	github.com/rogpeppe/go-internal v1.14.1 // indirect
 	github.com/txthinking/runnergroup v0.0.0-20250224021307-5864ffeb65ae // indirect
-	go.yaml.in/yaml/v2 v2.4.3 // indirect
-	golang.org/x/sync v0.19.0 // indirect
+	go.yaml.in/yaml/v2 v2.4.4 // indirect
+	golang.org/x/sync v0.20.0 // indirect
+	golang.org/x/tools v0.41.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -12,37 +12,34 @@ github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPd
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
 github.com/babolivier/go-doh-client v0.0.0-20201028162107-a76cff4cb8b6 h1:4NNbNM2Iq/k57qEu7WfL67UrbPq1uFWxW4qODCohi+0=
 github.com/babolivier/go-doh-client v0.0.0-20201028162107-a76cff4cb8b6/go.mod h1:J29hk+f9lJrblVIfiJOtTFk+OblBawmib4uz/VdKzlg=
+github.com/beevik/ntp v1.5.0 h1:y+uj/JjNwlY2JahivxYvtmv4ehfi3h74fAuABB9ZSM4=
+github.com/beevik/ntp v1.5.0/go.mod h1:mJEhBrwT76w9D+IfOEGvuzyuudiW9E52U2BaTrMOYow=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/d4l3k/messagediff v1.2.1 h1:ZcAIMYsUg0EAp9X+tt8/enBE/Q8Yd5kzPynLyKptt9U=
 github.com/d4l3k/messagediff v1.2.1/go.mod h1:Oozbb1TVXFac9FtSIxHBMnBCq2qeH/2KkEQxENCrlLo=
 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/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
 github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/jarcoal/httpmock v1.0.8 h1:8kI16SoO6LQKgPE7PvQuV+YuD/inwHd7fOOe2zMbo4k=
 github.com/jarcoal/httpmock v1.0.8/go.mod h1:ATjnClrvW/3tijVmpL/va5Z3aAyGvqU3gCT8nX0Txik=
-github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
-github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/klauspost/compress v1.18.3 h1:9PJRvfbmTabkOX8moIpXPbMMbYN60bWImDDU7L+/6zw=
+github.com/klauspost/compress v1.18.3/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
 github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mccutchen/go-httpbin v1.1.1 h1:aEws49HEJEyXHLDnshQVswfUlCVoS8g6h9YaDyaW7RE=
@@ -51,13 +48,16 @@ github.com/miekg/dns v1.1.51 h1:0+Xg7vObnhrz/4ZCZcZh7zPXlmU0aveS2HDBd0m0qSo=
 github.com/miekg/dns v1.1.51/go.mod h1:2Z9d3CP1LQWihRZUf29mQ19yDThaI4DAYzte2CaQW5c=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
-github.com/panjf2000/ants/v2 v2.11.5 h1:a7LMnMEeux/ebqTux140tRiaqcFTV0q2bEHF03nl6Rg=
-github.com/panjf2000/ants/v2 v2.11.5/go.mod h1:8u92CYMUc6gyvTIw8Ru7Mt7+/ESnJahz5EVtqfrilek=
+github.com/ncruces/go-dns v1.3.2 h1:kBLuUZBgkQ4qF4WDXZRQ4rG0Gk6sLVJQ5tESkWrxUa0=
+github.com/ncruces/go-dns v1.3.2/go.mod h1:tuzixNY8PY/M7yUzcvRbUaeLs3ifIdydpi5H2bfRU+s=
+github.com/panjf2000/ants/v2 v2.12.0 h1:u9JhESo83i/GkZnhfTNuFMMWcNt7mnV1bGJ6FT4wXH8=
+github.com/panjf2000/ants/v2 v2.12.0/go.mod h1:tSQuaNQ6r6NRhPt+IZVUevvDyFMTs+eS4ztZc52uJTY=
 github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc=
 github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
-github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8=
-github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pelletier/go-toml/v2 v2.3.0 h1:k59bC/lIZREW0/iVaQR8nDHxVq8OVlIzYCOJf421CaM=
+github.com/pelletier/go-toml/v2 v2.3.0/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
+github.com/pires/go-proxyproto v0.11.0 h1:gUQpS85X/VJMdUsYyEgyn59uLJvGqPhJV5YvG68wXH4=
+github.com/pires/go-proxyproto v0.11.0/go.mod h1:ZKAAyp3cgy5Y5Mo4n9AlScrkCZwUy0g3Jf+slqQVcuU=
 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/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
@@ -66,13 +66,12 @@ github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNw
 github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
 github.com/prometheus/common v0.67.5 h1:pIgK94WWlQt1WLwAC5j2ynLaBRDiinoAb86HZHTUGI4=
 github.com/prometheus/common v0.67.5/go.mod h1:SjE/0MzDEEAyrdr5Gqc6G+sXI67maCxzaT3A2+HqjUw=
-github.com/prometheus/procfs v0.19.2 h1:zUMhqEW66Ex7OXIiDkll3tl9a1ZdilUOd/F6ZXw4Vws=
-github.com/prometheus/procfs v0.19.2/go.mod h1:M0aotyiemPhBCM0z5w87kL22CxfcH05ZpYlu+b4J7mw=
-github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
-github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
-github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
-github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY=
-github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ=
+github.com/prometheus/procfs v0.20.1 h1:XwbrGOIplXW/AU3YhIhLODXMJYyC1isLFfYCsTEycfc=
+github.com/prometheus/procfs v0.20.1/go.mod h1:o9EMBZGRyvDrSPH1RqdxhojkuXstoe4UlK79eF5TGGo=
+github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rs/zerolog v1.35.0 h1:VD0ykx7HMiMJytqINBsKcbLS+BJ4WYjz+05us+LRTdI=
+github.com/rs/zerolog v1.35.0/go.mod h1:EjML9kdfa/RMA7h/6z6pYmq1ykOuA8/mjWaEvGI+jcw=
 github.com/smira/go-statsd v1.3.4 h1:kBYWcLSGT+qC6JVbvfz48kX7mQys32fjDOPrfmsSx2c=
 github.com/smira/go-statsd v1.3.4/go.mod h1:RjdsESPgDODtg1VpVVf9MJrEW2Hw0wtRNbmB1CAhu6A=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
@@ -87,6 +86,8 @@ github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXl
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/things-go/go-socks5 v0.1.0 h1:4f5dz0iMQ6cA4wseFmyLmCHmg3SWJTW92ndrKS6oERg=
+github.com/things-go/go-socks5 v0.1.0/go.mod h1:Riabiyu52kLsla0YmJqunt1c1JEl6iXSr4bRd7swFEA=
 github.com/txthinking/runnergroup v0.0.0-20210608031112-152c7c4432bf/go.mod h1:CLUSJbazqETbaR+i0YAhXBICV9TrKH93pziccMhmhpM=
 github.com/txthinking/runnergroup v0.0.0-20250224021307-5864ffeb65ae h1:ArVM1jICfm7g4E4dBet+KHUFMLuxmj1Nxdp/tr3ByCU=
 github.com/txthinking/runnergroup v0.0.0-20250224021307-5864ffeb65ae/go.mod h1:cldYm15/XHcGt7ndItnEWHwFZo7dinU+2QoyjfErhsI=
@@ -99,37 +100,36 @@ github.com/yl2chen/cidranger v1.0.2/go.mod h1:9U1yz7WPYDwf0vpNWFaeRh0bjwz5RVgRy/
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-go.yaml.in/yaml/v2 v2.4.3 h1:6gvOSjQoTB3vt1l+CU+tSyi/HOjfOjRLJ4YwYZGwRO0=
-go.yaml.in/yaml/v2 v2.4.3/go.mod h1:zSxWcmIDjOzPXpjlTTbAsKokqkDNAVtZO0WOMiT90s8=
+go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=
+go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
-golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=
+golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
+golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.7.0 h1:LapD9S96VoQRhi/GrNTqeBJFrUjs5UHCAtTlgwA5oZA=
 golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.32.0 h1:9F4d3PHLljb6x//jOyokMv3eX+YDeepZSEo3mFJy93c=
+golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
-golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
-golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
+golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0=
+golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
-golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
-golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
+golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=
@@ -140,8 +140,9 @@ golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.3.0 h1:SrNbZl6ECOS1qFzgTdQfWXZM9XBkiA6tkFrH9YSTPHM=
 golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k=
+golang.org/x/tools v0.41.0 h1:a9b8iMweWG+S0OBnlU36rzLp20z1Rp10w+IY2czHTQc=
+golang.org/x/tools v0.41.0/go.mod h1:XSY6eDqxVNiYgezAVqqCeihT4j1U2CCsqvH3WhQpnlg=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
 google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=

internal/cli/access.go

@@ -1,22 +1,16 @@
 package cli
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
-	"io"
 	"net"
-	"net/http"
 	"net/url"
 	"os"
 	"strconv"
-	"strings"
 	"sync"
 
-	"github.com/9seconds/mtg/v2/essentials"
 	"github.com/9seconds/mtg/v2/internal/config"
 	"github.com/9seconds/mtg/v2/internal/utils"
-	"github.com/9seconds/mtg/v2/mtglib"
 )
 
 type accessResponse struct {
@@ -61,14 +55,14 @@ func (a *Access) Run(cli *CLI, version string) error {
 	}
 
 	wg := &sync.WaitGroup{}
-	wg.Add(2)
-
-	go func() {
-		defer wg.Done()
 
+	wg.Go(func() {
 		ip := a.PublicIPv4
 		if ip == nil {
-			ip = a.getIP(ntw, "tcp4")
+			ip = conf.PublicIPv4.Get(nil)
+		}
+		if ip == nil {
+			ip = getIP(ntw, "tcp4")
 		}
 
 		if ip != nil {
@@ -76,14 +70,14 @@ func (a *Access) Run(cli *CLI, version string) error {
 		}
 
 		resp.IPv4 = a.makeURLs(conf, ip)
-	}()
-
-	go func() {
-		defer wg.Done()
-
+	})
+	wg.Go(func() {
 		ip := a.PublicIPv6
 		if ip == nil {
-			ip = a.getIP(ntw, "tcp6")
+			ip = conf.PublicIPv6.Get(nil)
+		}
+		if ip == nil {
+			ip = getIP(ntw, "tcp6")
 		}
 
 		if ip != nil {
@@ -91,7 +85,7 @@ func (a *Access) Run(cli *CLI, version string) error {
 		}
 
 		resp.IPv6 = a.makeURLs(conf, ip)
-	}()
+	})
 
 	wg.Wait()
 
@@ -106,40 +100,6 @@ func (a *Access) Run(cli *CLI, version string) error {
 	return nil
 }
 
-func (a *Access) getIP(ntw mtglib.Network, protocol string) net.IP {
-	client := ntw.MakeHTTPClient(func(ctx context.Context, network, address string) (essentials.Conn, error) {
-		return ntw.DialContext(ctx, protocol, address) //nolint: wrapcheck
-	})
-
-	req, err := http.NewRequest(http.MethodGet, "https://ifconfig.co", nil) //nolint: noctx
-	if err != nil {
-		panic(err)
-	}
-
-	req.Header.Add("Accept", "text/plain")
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil
-	}
-
-	if resp.StatusCode != http.StatusOK {
-		return nil
-	}
-
-	defer func() {
-		io.Copy(io.Discard, resp.Body) //nolint: errcheck
-		resp.Body.Close() //nolint: errcheck
-	}()
-
-	data, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil
-	}
-
-	return net.ParseIP(strings.TrimSpace(string(data)))
-}
-
 func (a *Access) makeURLs(conf *config.Config, ip net.IP) *accessResponseURLs {
 	if ip == nil {
 		return nil

internal/cli/cli.go

@@ -4,6 +4,7 @@ import "github.com/alecthomas/kong"
 
 type CLI struct {
 	GenerateSecret GenerateSecret   `kong:"cmd,help='Generate new proxy secret'"`
+	Doctor         Doctor           `kong:"cmd,help='Check that proxy can run correctly'"`
 	Access         Access           `kong:"cmd,help='Print access information.'"`
 	Run            Run              `kong:"cmd,help='Run proxy.'"`
 	SimpleRun      SimpleRun        `kong:"cmd,help='Run proxy without config file.'"`

internal/cli/doctor.go

@@ -0,0 +1,375 @@
+package cli
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"net"
+	"os"
+	"slices"
+	"strconv"
+	"strings"
+	"text/template"
+	"time"
+
+	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/9seconds/mtg/v2/internal/utils"
+	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/9seconds/mtg/v2/network/v2"
+	"github.com/beevik/ntp"
+)
+
+var (
+	tplError = template.Must(
+		template.New("").Parse("  ‼️ {{ .description }}: {{ .error }}\n"),
+	)
+
+	tplWDeprecatedConfig = template.Must(
+		template.New("").
+			Parse(`  ⚠️ Option {{ .old | printf "%q" }}{{ if .old_section }} from section [{{ .old_section }}]{{ end }} is deprecated and will be removed in v{{ .when }}. Please use {{ .new | printf "%q" }}{{ if .new_section }} in [{{ .new_section }}] section{{ end }} instead.` + "\n"),
+	)
+
+	tplOTimeSkewness = template.Must(
+		template.New("").
+			Parse("  ✅ Time drift is {{ .drift }}, but tolerate-time-skewness is {{ .value }}\n"),
+	)
+	tplWTimeSkewness = template.Must(
+		template.New("").
+			Parse("  ⚠️ Time drift is {{ .drift }}, but tolerate-time-skewness is {{ .value }}. Please check ntp.\n"),
+	)
+	tplETimeSkewness = template.Must(
+		template.New("").
+			Parse("  ❌ Time drift is {{ .drift }}, but tolerate-time-skewness is {{ .value }}. You will get many rejected connections!\n"),
+	)
+
+	tplODCConnect = template.Must(
+		template.New("").Parse("  ✅ DC {{ .dc }}\n"),
+	)
+	tplEDCConnect = template.Must(
+		template.New("").Parse("  ❌ DC {{ .dc }}: {{ .error }}\n"),
+	)
+
+	tplODNSSNIMatch = template.Must(
+		template.New("").Parse("  ✅ IP address {{ .ip }} matches secret hostname {{ .hostname }}\n"),
+	)
+	tplEDNSSNIMatch = template.Must(
+		template.New("").Parse("  ❌ Hostname {{ .hostname }} {{ if .resolved }}is resolved to {{ .resolved }} addresses, not {{ if .ip4 }}{{ .ip4 }}{{ else }}{{ .ip6 }}{{ end }}{{ else }}cannot be resolved to any host{{ end }}\n"),
+	)
+
+	tplOFrontingDomain = template.Must(
+		template.New("").Parse("  ✅ {{ .address }} is reachable\n"),
+	)
+	tplEFrontingDomain = template.Must(
+		template.New("").Parse("  ❌ {{ .address }}: {{ .error }}\n"),
+	)
+)
+
+type Doctor struct {
+	conf *config.Config
+
+	ConfigPath string `kong:"arg,required,type='existingfile',help='Path to the configuration file.',name='config-path'"` //nolint: lll
+}
+
+func (d *Doctor) Run(cli *CLI, version string) error {
+	conf, err := utils.ReadConfig(d.ConfigPath)
+	if err != nil {
+		return fmt.Errorf("cannot init config: %w", err)
+	}
+
+	d.conf = conf
+
+	fmt.Println("Deprecated options")
+	everythingOK := d.checkDeprecatedConfig()
+
+	fmt.Println("Time skewness")
+	everythingOK = d.checkTimeSkewness() && everythingOK
+
+	resolver, err := network.GetDNS(conf.GetDNS())
+	if err != nil {
+		return fmt.Errorf("cannot create DNS resolver: %w", err)
+	}
+
+	base := network.New(
+		resolver,
+		"",
+		conf.Network.Timeout.TCP.Get(10*time.Second),
+		conf.Network.Timeout.HTTP.Get(0),
+		conf.Network.Timeout.Idle.Get(0),
+	)
+
+	fmt.Println("Validate native network connectivity")
+	everythingOK = d.checkNetwork(base) && everythingOK
+
+	for _, url := range conf.Network.Proxies {
+		value, err := network.NewProxyNetwork(base, url.Get(nil))
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Validate network connectivity with proxy %s\n", url.Get(nil))
+		everythingOK = d.checkNetwork(value) && everythingOK
+	}
+
+	fmt.Println("Validate fronting domain connectivity")
+	everythingOK = d.checkFrontingDomain(base) && everythingOK
+
+	fmt.Println("Validate SNI-DNS match")
+	everythingOK = d.checkSecretHost(resolver, base) && everythingOK
+
+	if !everythingOK {
+		os.Exit(1)
+	}
+
+	return nil
+}
+
+func (d *Doctor) checkDeprecatedConfig() bool {
+	ok := true
+
+	if d.conf.DomainFrontingIP.Value != nil {
+		ok = false
+		tplWDeprecatedConfig.Execute(os.Stdout, map[string]string{ //nolint: errcheck
+			"when":        "2.3.0",
+			"old":         "domain-fronting-ip",
+			"old_section": "",
+			"new":         "ip",
+			"new_section": "domain-fronting",
+		})
+	}
+
+	if d.conf.DomainFrontingPort.Value != 0 {
+		ok = false
+		tplWDeprecatedConfig.Execute(os.Stdout, map[string]string{ //nolint: errcheck
+			"when":        "2.3.0",
+			"old":         "domain-fronting-port",
+			"old_section": "",
+			"new":         "port",
+			"new_section": "domain-fronting",
+		})
+	}
+
+	if d.conf.DomainFrontingProxyProtocol.Value {
+		ok = false
+		tplWDeprecatedConfig.Execute(os.Stdout, map[string]string{ //nolint: errcheck
+			"when":        "2.3.0",
+			"old":         "domain-fronting-proxy-protocol",
+			"old_section": "",
+			"new":         "proxy-protocol",
+			"new_section": "domain-fronting",
+		})
+	}
+
+	if d.conf.Network.DOHIP.Value != nil {
+		ok = false
+		tplWDeprecatedConfig.Execute(os.Stdout, map[string]string{ //nolint: errcheck
+			"when":        "2.3.0",
+			"old":         "doh-ip",
+			"old_section": "network",
+			"new":         "dns",
+			"new_section": "network",
+		})
+	}
+
+	if ok {
+		fmt.Println("  ✅ All good")
+	}
+
+	return ok
+}
+
+func (d *Doctor) checkTimeSkewness() bool {
+	response, err := ntp.Query("0.pool.ntp.org")
+	if err != nil {
+		tplError.Execute(os.Stdout, map[string]any{ //nolint: errcheck
+			"description": "cannot access ntp pool",
+			"error":       err,
+		})
+		return false
+	}
+
+	skewness := response.ClockOffset.Abs()
+	confValue := d.conf.TolerateTimeSkewness.Get(mtglib.DefaultTolerateTimeSkewness)
+	diff := float64(skewness) / float64(confValue)
+	tplData := map[string]any{
+		"drift": response.ClockOffset,
+		"value": confValue,
+	}
+
+	switch {
+	case diff < 0.3:
+		tplOTimeSkewness.Execute(os.Stdout, tplData) //nolint: errcheck
+		return true
+	case diff < 0.7:
+		tplWTimeSkewness.Execute(os.Stdout, tplData) //nolint: errcheck
+	default:
+		tplETimeSkewness.Execute(os.Stdout, tplData) //nolint: errcheck
+	}
+
+	return false
+}
+
+func (d *Doctor) checkNetwork(ntw mtglib.Network) bool {
+	dcs := slices.Collect(maps.Keys(essentials.TelegramCoreAddresses))
+	slices.Sort(dcs)
+
+	ok := true
+
+	for _, dc := range dcs {
+		err := d.checkNetworkAddresses(ntw, essentials.TelegramCoreAddresses[dc])
+		if err == nil {
+			tplODCConnect.Execute(os.Stdout, map[string]any{ //nolint: errcheck
+				"dc": dc,
+			})
+		} else {
+			tplEDCConnect.Execute(os.Stdout, map[string]any{ //nolint: errcheck
+				"dc":    dc,
+				"error": err,
+			})
+			ok = false
+		}
+	}
+
+	return ok
+}
+
+func (d *Doctor) checkNetworkAddresses(ntw mtglib.Network, addresses []string) error {
+	checkAddresses := []string{}
+
+	switch d.conf.PreferIP.Get("prefer-ip4") {
+	case "only-ipv4":
+		for _, addr := range addresses {
+			host, _, err := net.SplitHostPort(addr)
+			if err != nil {
+				panic(err)
+			}
+
+			if ip := net.ParseIP(host); ip != nil && ip.To4() != nil {
+				checkAddresses = append(checkAddresses, addr)
+			}
+		}
+	case "only-ipv6":
+		for _, addr := range addresses {
+			host, _, err := net.SplitHostPort(addr)
+			if err != nil {
+				panic(err)
+			}
+
+			if ip := net.ParseIP(host); ip != nil && ip.To4() == nil {
+				checkAddresses = append(checkAddresses, addr)
+			}
+		}
+	default:
+		checkAddresses = addresses
+	}
+
+	if len(checkAddresses) == 0 {
+		return fmt.Errorf("no suitable addresses after IP version filtering")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	var (
+		conn net.Conn
+		err  error
+	)
+
+	for _, addr := range checkAddresses {
+		conn, err = ntw.DialContext(ctx, "tcp", addr)
+		if err != nil {
+			continue
+		}
+
+		conn.Close() //nolint: errcheck
+
+		return nil
+	}
+
+	return err
+}
+
+func (d *Doctor) checkFrontingDomain(ntw mtglib.Network) bool {
+	host := d.conf.Secret.Host
+	if ip := d.conf.GetDomainFrontingIP(nil); ip != "" {
+		host = ip
+	}
+
+	port := d.conf.GetDomainFrontingPort(mtglib.DefaultDomainFrontingPort)
+	address := net.JoinHostPort(host, strconv.Itoa(int(port)))
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	dialer := ntw.NativeDialer()
+
+	conn, err := dialer.DialContext(ctx, "tcp", address)
+	if err != nil {
+		tplEFrontingDomain.Execute(os.Stdout, map[string]any{ //nolint: errcheck
+			"address": address,
+			"error":   err,
+		})
+		return false
+	}
+
+	conn.Close() //nolint: errcheck
+
+	tplOFrontingDomain.Execute(os.Stdout, map[string]any{ //nolint: errcheck
+		"address": address,
+	})
+
+	return true
+}
+
+func (d *Doctor) checkSecretHost(resolver *net.Resolver, ntw mtglib.Network) bool {
+	addresses, err := resolver.LookupIPAddr(context.Background(), d.conf.Secret.Host)
+	if err != nil {
+		tplError.Execute(os.Stdout, map[string]any{ //nolint: errcheck
+			"description": fmt.Sprintf("cannot resolve DNS name of %s", d.conf.Secret.Host),
+			"error":       err,
+		})
+		return false
+	}
+
+	ourIP4 := d.conf.PublicIPv4.Get(nil)
+	if ourIP4 == nil {
+		ourIP4 = getIP(ntw, "tcp4")
+	}
+
+	ourIP6 := d.conf.PublicIPv6.Get(nil)
+	if ourIP6 == nil {
+		ourIP6 = getIP(ntw, "tcp6")
+	}
+
+	if ourIP4 == nil && ourIP6 == nil {
+		tplError.Execute(os.Stdout, map[string]any{ //nolint: errcheck
+			"description": "cannot detect public IP address",
+			"error":       errors.New("cannot detect automatically and public-ipv4/public-ipv6 are not set in config"),
+		})
+		return false
+	}
+
+	strAddresses := []string{}
+	for _, value := range addresses {
+		if (ourIP4 != nil && value.IP.String() == ourIP4.String()) ||
+			(ourIP6 != nil && value.IP.String() == ourIP6.String()) {
+			tplODNSSNIMatch.Execute(os.Stdout, map[string]any{ //nolint: errcheck
+				"ip":       value.IP,
+				"hostname": d.conf.Secret.Host,
+			})
+			return true
+		}
+
+		strAddresses = append(strAddresses, `"`+value.IP.String()+`"`)
+	}
+
+	tplEDNSSNIMatch.Execute(os.Stdout, map[string]any{ //nolint: errcheck
+		"hostname": d.conf.Secret.Host,
+		"resolved": strings.Join(strAddresses, ", "),
+		"ip4":      ourIP4,
+		"ip6":      ourIP6,
+	})
+
+	return false
+}

internal/cli/run_proxy.go

@@ -4,19 +4,21 @@ import (
 	"context"
 	"fmt"
 	"net"
-	"net/url"
 	"os"
+	"time"
 
 	"github.com/9seconds/mtg/v2/antireplay"
 	"github.com/9seconds/mtg/v2/events"
 	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/9seconds/mtg/v2/internal/proxyprotocol"
 	"github.com/9seconds/mtg/v2/internal/utils"
 	"github.com/9seconds/mtg/v2/ipblocklist"
 	"github.com/9seconds/mtg/v2/ipblocklist/files"
 	"github.com/9seconds/mtg/v2/logger"
 	"github.com/9seconds/mtg/v2/mtglib"
-	"github.com/9seconds/mtg/v2/network"
+	"github.com/9seconds/mtg/v2/network/v2"
 	"github.com/9seconds/mtg/v2/stats"
+	"github.com/pires/go-proxyproto"
 	"github.com/rs/zerolog"
 	"github.com/yl2chen/cidranger"
 )
@@ -38,43 +40,41 @@ func makeLogger(conf *config.Config) mtglib.Logger {
 }
 
 func makeNetwork(conf *config.Config, version string) (mtglib.Network, error) {
-	tcpTimeout := conf.Network.Timeout.TCP.Get(network.DefaultTimeout)
-	httpTimeout := conf.Network.Timeout.HTTP.Get(network.DefaultHTTPTimeout)
-	dohIP := conf.Network.DOHIP.Get(net.ParseIP(network.DefaultDOHHostname)).String()
-	userAgent := "mtg/" + version
-
-	baseDialer, err := network.NewDefaultDialer(tcpTimeout, 0)
+	resolver, err := network.GetDNS(conf.GetDNS())
 	if err != nil {
-		return nil, fmt.Errorf("cannot build a default dialer: %w", err)
+		return nil, fmt.Errorf("cannot create DNS resolver: %w", err)
 	}
 
-	if len(conf.Network.Proxies) == 0 {
-		return network.NewNetwork(baseDialer, userAgent, dohIP, httpTimeout) //nolint: wrapcheck
-	}
+	base := network.New(
+		resolver,
+		"",
+		conf.Network.Timeout.TCP.Get(0),
+		conf.Network.Timeout.HTTP.Get(0),
+		conf.Network.Timeout.Idle.Get(0),
+	)
 
-	proxyURLs := make([]*url.URL, 0, len(conf.Network.Proxies))
-
-	for _, v := range conf.Network.Proxies {
-		if value := v.Get(nil); value != nil {
-			proxyURLs = append(proxyURLs, value)
-		}
-	}
-
-	if len(proxyURLs) == 1 {
-		socksDialer, err := network.NewSocks5Dialer(baseDialer, proxyURLs[0])
+	proxyDialers := make([]mtglib.Network, len(conf.Network.Proxies))
+	for idx, v := range conf.Network.Proxies {
+		value, err := network.NewProxyNetwork(base, v.Get(nil))
 		if err != nil {
-			return nil, fmt.Errorf("cannot build socks5 dialer: %w", err)
+			return nil, fmt.Errorf("cannot use %v for proxy url: %w", v.Get(nil), err)
 		}
-
-		return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout) //nolint: wrapcheck
+		proxyDialers[idx] = value
 	}
 
-	socksDialer, err := network.NewLoadBalancedSocks5Dialer(baseDialer, proxyURLs)
+	switch len(proxyDialers) {
+	case 0:
+		return base, nil
+	case 1:
+		return proxyDialers[0], nil
+	}
+
+	value, err := network.Join(proxyDialers...)
 	if err != nil {
-		return nil, fmt.Errorf("cannot build socks5 dialer: %w", err)
+		panic(err)
 	}
 
-	return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout) //nolint: wrapcheck
+	return value, nil
 }
 
 func makeAntiReplayCache(conf *config.Config) mtglib.AntiReplayCache {
@@ -240,6 +240,11 @@ func runProxy(conf *config.Config, version string) error { //nolint: funlen
 		return fmt.Errorf("cannot build ip allowlist: %w", err)
 	}
 
+	doppelGangerURLs := make([]string, len(conf.Defense.Doppelganger.URLs))
+	for i, v := range conf.Defense.Doppelganger.URLs {
+		doppelGangerURLs[i] = v.String()
+	}
+
 	opts := mtglib.ProxyOpts{
 		Logger:          logger,
 		Network:         ntw,
@@ -248,12 +253,22 @@ func runProxy(conf *config.Config, version string) error { //nolint: funlen
 		IPAllowlist:     allowlist,
 		EventStream:     eventStream,
 
-		Secret:             conf.Secret,
-		DomainFrontingPort: conf.DomainFrontingPort.Get(mtglib.DefaultDomainFrontingPort),
-		PreferIP:           conf.PreferIP.Get(mtglib.DefaultPreferIP),
+		Secret:                      conf.Secret,
+		Concurrency:                 conf.GetConcurrency(mtglib.DefaultConcurrency),
+		DomainFrontingPort:          conf.GetDomainFrontingPort(mtglib.DefaultDomainFrontingPort),
+		DomainFrontingIP:            conf.GetDomainFrontingIP(nil),
+		DomainFrontingProxyProtocol: conf.GetDomainFrontingProxyProtocol(false),
+		PreferIP:                    conf.PreferIP.Get(mtglib.DefaultPreferIP),
+		AutoUpdate:                  conf.AutoUpdate.Get(false),
 
 		AllowFallbackOnUnknownDC: conf.AllowFallbackOnUnknownDC.Get(false),
 		TolerateTimeSkewness:     conf.TolerateTimeSkewness.Value,
+		IdleTimeout:              conf.Network.Timeout.Idle.Get(time.Minute),
+
+		DoppelGangerURLs:    doppelGangerURLs,
+		DoppelGangerPerRaid: conf.Defense.Doppelganger.Repeats.Get(mtglib.DoppelGangerPerRaid),
+		DoppelGangerEach:    conf.Defense.Doppelganger.UpdateEach.Get(mtglib.DoppelGangerEach),
+		DoppelGangerDRS:     conf.Defense.Doppelganger.DRS.Get(false),
 	}
 
 	proxy, err := mtglib.NewProxy(opts)
@@ -266,6 +281,14 @@ func runProxy(conf *config.Config, version string) error { //nolint: funlen
 		return fmt.Errorf("cannot start proxy: %w", err)
 	}
 
+	if conf.ProxyProtocolListener.Get(false) {
+		listener = &proxyprotocol.ListenerAdapter{
+			Listener: proxyproto.Listener{
+				Listener: listener,
+			},
+		}
+	}
+
 	ctx := utils.RootContext()
 
 	go proxy.Serve(listener) //nolint: errcheck

internal/cli/simple_run.go

@@ -18,7 +18,8 @@ type SimpleRun struct {
 	TCPBuffer           string        `kong:"name='tcp-buffer',short='b',default='4KB',help='Deprecated and ignored'"`                                                 //nolint: lll
 	PreferIP            string        `kong:"name='prefer-ip',short='i',default='prefer-ipv6',help='IP preference. By default we prefer IPv6 with fallback to IPv4.'"` //nolint: lll
 	DomainFrontingPort  uint64        `kong:"name='domain-fronting-port',short='p',default='443',help='A port to access for domain fronting.'"`                        //nolint: lll
-	DOHIP               net.IP        `kong:"name='doh-ip',short='n',default='9.9.9.9',help='IP address of DNS-over-HTTP to use.'"`                                    //nolint: lll
+	DomainFrontingIP    string        `kong:"name='domain-fronting-ip',help='An IP address to use for domain fronting instead of resolving the hostname via DNS.'"`    //nolint: lll
+	DOHIP               net.IP        `kong:"name='doh-ip',short='n',default='1.1.1.1',help='IP address of DNS-over-HTTP to use.'"`                                    //nolint: lll
 	Timeout             time.Duration `kong:"name='timeout',short='t',default='10s',help='Network timeout to use'"`                                                    //nolint: lll
 	Socks5Proxies       []string      `kong:"name='socks5-proxy',short='s',help='Socks5 proxies to use for network access.'"`                                          //nolint: lll
 	AntiReplayCacheSize string        `kong:"name='antireplay-cache-size',short='a',default='1MB',help='A size of anti-replay cache to use.'"`                         //nolint: lll
@@ -47,6 +48,12 @@ func (s *SimpleRun) Run(cli *CLI, version string) error { //nolint: cyclop,funle
 		return fmt.Errorf("incorrect domain-fronting-port: %w", err)
 	}
 
+	if s.DomainFrontingIP != "" {
+		if err := conf.DomainFrontingIP.Set(s.DomainFrontingIP); err != nil {
+			return fmt.Errorf("incorrect domain-fronting-ip: %w", err)
+		}
+	}
+
 	if err := conf.Network.DOHIP.Set(s.DOHIP.String()); err != nil {
 		return fmt.Errorf("incorrect doh-ip: %w", err)
 	}

internal/cli/utils.go

@@ -0,0 +1,51 @@
+package cli
+
+import (
+	"context"
+	"io"
+	"net"
+	"net/http"
+	"strings"
+
+	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/9seconds/mtg/v2/mtglib"
+)
+
+func getIP(ntw mtglib.Network, protocol string) net.IP {
+	dialer := ntw.NativeDialer()
+	client := ntw.MakeHTTPClient(func(ctx context.Context, network, address string) (essentials.Conn, error) {
+		conn, err := dialer.DialContext(ctx, protocol, address)
+		if err != nil {
+			return nil, err
+		}
+		return essentials.WrapNetConn(conn), err
+	})
+
+	req, err := http.NewRequest(http.MethodGet, "https://ifconfig.co", nil) //nolint: noctx
+	if err != nil {
+		panic(err)
+	}
+
+	req.Header.Add("Accept", "text/plain")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil
+	}
+
+	defer func() {
+		io.Copy(io.Discard, resp.Body) //nolint: errcheck
+		resp.Body.Close()              //nolint: errcheck
+	}()
+
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil
+	}
+
+	return net.ParseIP(strings.TrimSpace(string(data)))
+}

internal/config/config.go

@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"net"
+	"net/url"
 
 	"github.com/9seconds/mtg/v2/mtglib"
 )
@@ -21,23 +23,40 @@ type ListConfig struct {
 }
 
 type Config struct {
-	Debug                    TypeBool        `json:"debug"`
-	AllowFallbackOnUnknownDC TypeBool        `json:"allowFallbackOnUnknownDc"`
-	Secret                   mtglib.Secret   `json:"secret"`
-	BindTo                   TypeHostPort    `json:"bindTo"`
-	PreferIP                 TypePreferIP    `json:"preferIp"`
-	DomainFrontingPort       TypePort        `json:"domainFrontingPort"`
-	TolerateTimeSkewness     TypeDuration    `json:"tolerateTimeSkewness"`
-	Concurrency              TypeConcurrency `json:"concurrency"`
-	Defense                  struct {
+	Debug                       TypeBool        `json:"debug"`
+	AllowFallbackOnUnknownDC    TypeBool        `json:"allowFallbackOnUnknownDc"`
+	Secret                      mtglib.Secret   `json:"secret"`
+	BindTo                      TypeHostPort    `json:"bindTo"`
+	ProxyProtocolListener       TypeBool        `json:"proxyProtocolListener"`
+	PreferIP                    TypePreferIP    `json:"preferIp"`
+	AutoUpdate                  TypeBool        `json:"autoUpdate"`
+	DomainFrontingPort          TypePort        `json:"domainFrontingPort"`
+	DomainFrontingIP            TypeIP          `json:"domainFrontingIp"`
+	DomainFrontingProxyProtocol TypeBool        `json:"domainFrontingProxyProtocol"`
+	TolerateTimeSkewness        TypeDuration    `json:"tolerateTimeSkewness"`
+	Concurrency                 TypeConcurrency `json:"concurrency"`
+	PublicIPv4                  TypeIP          `json:"publicIpv4"`
+	PublicIPv6                  TypeIP          `json:"publicIpv6"`
+	DomainFronting              struct {
+		IP            TypeIP   `json:"ip"`
+		Port          TypePort `json:"port"`
+		ProxyProtocol TypeBool `json:"proxyProtocol"`
+	} `json:"domainFronting"`
+	Defense struct {
 		AntiReplay struct {
 			Optional
 
 			MaxSize   TypeBytes     `json:"maxSize"`
 			ErrorRate TypeErrorRate `json:"errorRate"`
 		} `json:"antiReplay"`
-		Blocklist ListConfig `json:"blocklist"`
-		Allowlist ListConfig `json:"allowlist"`
+		Blocklist    ListConfig `json:"blocklist"`
+		Allowlist    ListConfig `json:"allowlist"`
+		Doppelganger struct {
+			URLs       []TypeHttpsURL  `json:"urls"`
+			Repeats    TypeConcurrency `json:"repeats_per_raid"`
+			UpdateEach TypeDuration    `json:"raid_each"`
+			DRS        TypeBool        `json:"drs"`
+		} `json:"doppelganger"`
 	} `json:"defense"`
 	Network struct {
 		Timeout struct {
@@ -46,6 +65,7 @@ type Config struct {
 			Idle TypeDuration `json:"idle"`
 		} `json:"timeout"`
 		DOHIP   TypeIP         `json:"dohIp"`
+		DNS     TypeDNSURI     `json:"dns"`
 		Proxies []TypeProxyURL `json:"proxies"`
 	} `json:"network"`
 	Stats struct {
@@ -66,6 +86,44 @@ type Config struct {
 	} `json:"stats"`
 }
 
+func (c *Config) GetConcurrency(defaultValue uint) uint {
+	if concurrency := c.Concurrency.Get(0); concurrency != 0 {
+		return concurrency
+	}
+	return c.Concurrency.Get(defaultValue)
+}
+
+func (c *Config) GetDNS() *url.URL {
+	var dohURL *url.URL
+
+	if dohIP := c.Network.DOHIP.Get(nil); dohIP != nil {
+		dohURL, _ = url.Parse("https://" + dohIP.String())
+	}
+
+	return c.Network.DNS.Get(dohURL)
+}
+
+func (c *Config) GetDomainFrontingPort(defaultValue uint) uint {
+	if port := c.DomainFronting.Port.Get(0); port != 0 {
+		return port
+	}
+	return c.DomainFrontingPort.Get(defaultValue)
+}
+
+func (c *Config) GetDomainFrontingIP(defaultValue net.IP) string {
+	if ip := c.DomainFronting.IP.Get(nil); ip != nil {
+		return ip.String()
+	}
+	if ip := c.DomainFrontingIP.Get(defaultValue); ip != nil {
+		return ip.String()
+	}
+	return ""
+}
+
+func (c *Config) GetDomainFrontingProxyProtocol(defaultValue bool) bool {
+	return c.DomainFronting.ProxyProtocol.Get(false) || c.DomainFrontingProxyProtocol.Get(defaultValue)
+}
+
 func (c *Config) Validate() error {
 	if !c.Secret.Valid() {
 		return fmt.Errorf("invalid secret %s", c.Secret.String())

internal/config/config_test.go

@@ -42,6 +42,32 @@ func (suite *ConfigTestSuite) TestParseMinimalConfig() {
 	suite.Equal("0.0.0.0:3128", conf.BindTo.String())
 }
 
+func (suite *ConfigTestSuite) TestParsePublicIP() {
+	conf, err := config.Parse(suite.ReadConfig("public_ip.toml"))
+	suite.NoError(err)
+	suite.Equal("203.0.113.1", conf.PublicIPv4.Get(nil).String())
+	suite.Equal("2001:db8::1", conf.PublicIPv6.Get(nil).String())
+}
+
+func (suite *ConfigTestSuite) TestParsePublicIPv4Only() {
+	conf, err := config.Parse(suite.ReadConfig("public_ip_v4_only.toml"))
+	suite.NoError(err)
+	suite.Equal("203.0.113.1", conf.PublicIPv4.Get(nil).String())
+	suite.Nil(conf.PublicIPv6.Get(nil))
+}
+
+func (suite *ConfigTestSuite) TestParsePublicIPInvalid() {
+	_, err := config.Parse(suite.ReadConfig("public_ip_invalid.toml"))
+	suite.Error(err)
+}
+
+func (suite *ConfigTestSuite) TestParsePublicIPNotSet() {
+	conf, err := config.Parse(suite.ReadConfig("minimal.toml"))
+	suite.NoError(err)
+	suite.Nil(conf.PublicIPv4.Get(nil))
+	suite.Nil(conf.PublicIPv6.Get(nil))
+}
+
 func (suite *ConfigTestSuite) TestString() {
 	conf, err := config.Parse(suite.ReadConfig("minimal.toml"))
 	suite.NoError(err)

internal/config/parse.go

@@ -5,19 +5,30 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"github.com/pelletier/go-toml"
+	"github.com/pelletier/go-toml/v2"
 )
 
 type tomlConfig struct {
-	Debug                    bool   `toml:"debug" json:"debug,omitempty"`
-	AllowFallbackOnUnknownDC bool   `toml:"allow-fallback-on-unknown-dc" json:"allowFallbackOnUnknownDc,omitempty"`
-	Secret                   string `toml:"secret" json:"secret"`
-	BindTo                   string `toml:"bind-to" json:"bindTo"`
-	PreferIP                 string `toml:"prefer-ip" json:"preferIp,omitempty"`
-	DomainFrontingPort       uint   `toml:"domain-fronting-port" json:"domainFrontingPort,omitempty"`
-	TolerateTimeSkewness     string `toml:"tolerate-time-skewness" json:"tolerateTimeSkewness,omitempty"`
-	Concurrency              uint   `toml:"concurrency" json:"concurrency,omitempty"`
-	Defense                  struct {
+	Debug                       bool   `toml:"debug" json:"debug,omitempty"`
+	AllowFallbackOnUnknownDC    bool   `toml:"allow-fallback-on-unknown-dc" json:"allowFallbackOnUnknownDc,omitempty"`
+	Secret                      string `toml:"secret" json:"secret"`
+	BindTo                      string `toml:"bind-to" json:"bindTo"`
+	ProxyProtocolListener       bool   `toml:"proxy-protocol-listener" json:"proxyProtocolListener"`
+	PreferIP                    string `toml:"prefer-ip" json:"preferIp,omitempty"`
+	AutoUpdate                  bool   `toml:"auto-update" json:"autoUpdate,omitempty"`
+	DomainFrontingPort          uint   `toml:"domain-fronting-port" json:"domainFrontingPort,omitempty"`
+	DomainFrontingIP            string `toml:"domain-fronting-ip" json:"domainFrontingIp,omitempty"`
+	DomainFrontingProxyProtocol bool   `toml:"domain-fronting-proxy-protocol" json:"domainFrontingProxyProtocol,omitempty"`
+	TolerateTimeSkewness        string `toml:"tolerate-time-skewness" json:"tolerateTimeSkewness,omitempty"`
+	Concurrency                 uint   `toml:"concurrency" json:"concurrency,omitempty"`
+	PublicIPv4                  string `toml:"public-ipv4" json:"publicIpv4,omitempty"`
+	PublicIPv6                  string `toml:"public-ipv6" json:"publicIpv6,omitempty"`
+	DomainFronting              struct {
+		IP            string `toml:"ip" json:"ip,omitempty"`
+		Port          uint   `toml:"port" json:"port,omitempty"`
+		ProxyProtocol bool   `toml:"proxy-protocol" json:"proxyProtocol,omitempty"`
+	} `toml:"domain-fronting" json:"domainFronting,omitempty"`
+	Defense struct {
 		AntiReplay struct {
 			Enabled   bool    `toml:"enabled" json:"enabled,omitempty"`
 			MaxSize   string  `toml:"max-size" json:"maxSize,omitempty"`
@@ -35,6 +46,12 @@ type tomlConfig struct {
 			URLs                []string `toml:"urls" json:"urls,omitempty"`
 			UpdateEach          string   `toml:"update-each" json:"updateEach,omitempty"`
 		} `toml:"allowlist" json:"allowlist,omitempty"`
+		Doppelganger struct {
+			URLs       []string `toml:"urls" json:"urls,omitempty"`
+			Repeats    uint     `toml:"repeats-per-raid" json:"repeats_per_raid,omitempty"`
+			UpdateEach string   `toml:"raid-each" json:"raid_each,omitempty"`
+			DRS        bool     `toml:"drs" json:"drs,omitempty"`
+		} `toml:"doppelganger" json:"doppelganger,omitempty"`
 	} `toml:"defense" json:"defense,omitempty"`
 	Network struct {
 		Timeout struct {
@@ -43,6 +60,7 @@ type tomlConfig struct {
 			Idle string `toml:"idle" json:"idle,omitempty"`
 		} `toml:"timeout" json:"timeout,omitempty"`
 		DOHIP   string   `toml:"doh-ip" json:"dohIp,omitempty"`
+		DNS     string   `toml:"dns" json:"dns,omitempty"`
 		Proxies []string `toml:"proxies" json:"proxies,omitempty"`
 	} `toml:"network" json:"network,omitempty"`
 	Stats struct {

internal/config/testdata/public_ip.toml

@@ -0,0 +1,4 @@
+secret = "7oe1GqLy6TBc38CV3jx7q09nb29nbGUuY29t"
+bind-to = "0.0.0.0:3128"
+public-ipv4 = "203.0.113.1"
+public-ipv6 = "2001:db8::1"

internal/config/testdata/public_ip_invalid.toml

@@ -0,0 +1,3 @@
+secret = "7oe1GqLy6TBc38CV3jx7q09nb29nbGUuY29t"
+bind-to = "0.0.0.0:3128"
+public-ipv4 = "not-an-ip"

internal/config/testdata/public_ip_v4_only.toml

@@ -0,0 +1,3 @@
+secret = "7oe1GqLy6TBc38CV3jx7q09nb29nbGUuY29t"
+bind-to = "0.0.0.0:3128"
+public-ipv4 = "203.0.113.1"

internal/config/type_bool_test.go

@@ -20,7 +20,7 @@ type TypeBoolTestSuite struct {
 }
 
 func (suite *TypeBoolTestSuite) TestUnmarshalFail() {
-	testData := []interface{}{
+	testData := []any{
 		"",
 		"np",
 		"нет",
@@ -29,7 +29,7 @@ func (suite *TypeBoolTestSuite) TestUnmarshalFail() {
 	}
 
 	for _, v := range testData {
-		data, err := json.Marshal(map[string]interface{}{
+		data, err := json.Marshal(map[string]any{
 			"value": v,
 		})
 		suite.NoError(err)

internal/config/type_dc.go

@@ -0,0 +1,41 @@
+package config
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type TypeDC struct {
+	Value int
+}
+
+func (t *TypeDC) Set(value string) error {
+	parsed, err := strconv.ParseInt(value, 10, 16)
+	if err != nil {
+		return fmt.Errorf("cannot parse dc: %w", err)
+	}
+
+	if parsed < 0 {
+		parsed = -parsed
+	}
+
+	t.Value = int(parsed)
+
+	return nil
+}
+
+func (t *TypeDC) UnmarshalJSON(data []byte) error {
+	return t.Set(string(data))
+}
+
+func (t TypeDC) MarshalJSON() ([]byte, error) {
+	return []byte(t.String()), nil
+}
+
+func (t TypeDC) String() string {
+	return strconv.Itoa(t.Value)
+}
+
+func (t TypeDC) Get() int {
+	return t.Value
+}

internal/config/type_dc_test.go

@@ -0,0 +1,96 @@
+package config_test
+
+import (
+	"encoding/json"
+	"strconv"
+	"testing"
+
+	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+)
+
+type typeDCTestStruct struct {
+	Value config.TypeDC `json:"value"`
+}
+
+type TypeDCTestSuite struct {
+	suite.Suite
+}
+
+func (suite *TypeDCTestSuite) TestUnmarshalFail() {
+	testData := []string{
+		"-1s",
+		"1202002020202",
+		"xxx",
+		"-11111111111111",
+		"",
+	}
+
+	for _, v := range testData {
+		data, err := json.Marshal(map[string]string{
+			"value": v,
+		})
+		suite.NoError(err)
+
+		suite.T().Run(v, func(t *testing.T) {
+			assert.Error(t, json.Unmarshal(data, &typeDCTestStruct{}))
+		})
+	}
+}
+
+func (suite *TypeDCTestSuite) TestUnmarshalOk() {
+	testData := map[int]int{
+		1:   1,
+		-1:  1,
+		203: 203,
+	}
+
+	for value, expected := range testData {
+		data, err := json.Marshal(map[string]int{
+			"value": value,
+		})
+		suite.NoError(err)
+
+		suite.T().Run(strconv.Itoa(value), func(t *testing.T) {
+			testStruct := &typeDCTestStruct{}
+
+			assert.NoError(t, json.Unmarshal(data, testStruct))
+			assert.Equal(t, expected, testStruct.Value.Value)
+			assert.Equal(t, expected, testStruct.Value.Get())
+		})
+	}
+}
+
+func (suite *TypeDCTestSuite) TestMarshalOk() {
+	testData := map[string]int{
+		"1":   1,
+		"203": 203,
+	}
+
+	for k, v := range testData {
+		value := k
+		expected := v
+
+		suite.T().Run(value, func(t *testing.T) {
+			testStruct := &typeDCTestStruct{}
+
+			assert.NoError(t, testStruct.Value.Set(value))
+
+			data, err := json.Marshal(testStruct)
+			assert.NoError(t, err)
+
+			expectedJSON, err := json.Marshal(map[string]int{
+				"value": expected,
+			})
+			assert.NoError(t, err)
+
+			assert.JSONEq(t, string(expectedJSON), string(data))
+		})
+	}
+}
+
+func TestTypeDC(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &TypeDCTestSuite{})
+}

internal/config/type_dns_uri.go

@@ -0,0 +1,69 @@
+package config
+
+import (
+	"fmt"
+	"net"
+	"net/url"
+)
+
+type TypeDNSURI struct {
+	Value *url.URL
+}
+
+func (t *TypeDNSURI) Set(value string) error {
+	parsed, err := url.Parse(value)
+	if err != nil {
+		return fmt.Errorf("value is not URI: %w", err)
+	}
+
+	if parsed.Host == "" {
+		parsed.Host = parsed.Path
+		parsed.Path = ""
+		parsed.Scheme = "udp"
+	}
+
+	switch parsed.Scheme {
+	case "https", "tls":
+	case "udp":
+		if ip := net.ParseIP(parsed.Hostname()); ip == nil {
+			return fmt.Errorf("simple DNS must IP address: %s", parsed.Hostname())
+		}
+	default:
+		return fmt.Errorf("unsupported DNS type %s", parsed.Scheme)
+	}
+
+	if parsed.Scheme != "https" && parsed.Path != "" {
+		return fmt.Errorf("path is supported only for DoH: %s", parsed)
+	}
+
+	if parsed.User != nil {
+		return fmt.Errorf("used info is not supported: %s", parsed.User.String())
+	}
+
+	t.Value = parsed
+
+	return nil
+}
+
+func (t *TypeDNSURI) Get(defaultValue *url.URL) *url.URL {
+	if t.Value != nil {
+		return t.Value
+	}
+
+	return defaultValue
+}
+
+func (t *TypeDNSURI) UnmarshalText(data []byte) error {
+	return t.Set(string(data))
+}
+
+func (t TypeDNSURI) MarshalText() ([]byte, error) {
+	return []byte(t.String()), nil
+}
+
+func (t TypeDNSURI) String() string {
+	if t.Value == nil {
+		return ""
+	}
+	return t.Value.String()
+}

internal/config/type_dns_uri_test.go

@@ -0,0 +1,117 @@
+package config_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+)
+
+type typeDNSURITestStruct struct {
+	Value config.TypeDNSURI `json:"value"`
+}
+
+type TypeDNSURITestSuite struct {
+	suite.Suite
+}
+
+func (suite *TypeDNSURITestSuite) TestUnmarshalFail() {
+	testData := []string{
+		"xx",
+		"ppar",
+		"",
+		"dns://hahaha",
+		"udp://xcxxcv",
+		"udp://1.1.1.1/xcv",
+		"1.1.1.1/xxx",
+		"tls://dns/xx",
+		"tls://1.1.1.1/xx",
+		"https://user:password@1.1.1.1",
+		"tls://user:password@1.1.1.1",
+		"udp://user:password@1.1.1.1",
+	}
+
+	for _, v := range testData {
+		data, err := json.Marshal(map[string]string{
+			"value": v,
+		})
+		suite.NoError(err)
+
+		suite.T().Run(v, func(t *testing.T) {
+			assert.Error(t, json.Unmarshal(data, &typeDNSURITestStruct{}))
+		})
+	}
+}
+
+func (suite *TypeDNSURITestSuite) TestUnmarshalOk() {
+	testData := []string{
+		"1.1.1.1",
+		"tls://1.1.1.1",
+		"tls://dns.google",
+		"https://1.1.1.1",
+		"https://1.1.1.1/dns-query",
+		"https://dns.google",
+		"https://dns.google/dns-query",
+		"udp://1.1.1.1",
+	}
+
+	for _, v := range testData {
+		data, err := json.Marshal(map[string]string{
+			"value": v,
+		})
+		suite.NoError(err)
+
+		suite.T().Run(v, func(t *testing.T) {
+			testStruct := &typeDNSURITestStruct{}
+			assert.NoError(t, json.Unmarshal(data, testStruct))
+			if v == "1.1.1.1" {
+				v = "udp://" + v
+			}
+			assert.Equal(t, v, testStruct.Value.String())
+		})
+	}
+}
+
+func (suite *TypeDNSURITestSuite) TestMarshalOk() {
+	testData := []string{
+		"tls://1.1.1.1",
+		"tls://dns.google",
+		"https://1.1.1.1",
+		"https://1.1.1.1/dns-query",
+	}
+
+	for _, v := range testData {
+		suite.T().Run(v, func(t *testing.T) {
+			testStruct := &typePreferIPTestStruct{
+				Value: config.TypePreferIP{
+					Value: v,
+				},
+			}
+
+			encodedJSON, err := json.Marshal(testStruct)
+			assert.NoError(t, err)
+
+			expectedJSON, err := json.Marshal(map[string]string{
+				"value": v,
+			})
+			assert.NoError(t, err)
+
+			assert.JSONEq(t, string(expectedJSON), string(encodedJSON))
+		})
+	}
+}
+
+func (suite *TypeDNSURITestSuite) TestGet() {
+	value := config.TypeDNSURI{}
+	suite.Nil(value.Get(nil))
+
+	suite.NoError(value.Set("tls://1.1.1.1"))
+	suite.NotNil(value.Get(nil))
+}
+
+func TestDNSURI(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &TypeDNSURITestSuite{})
+}

internal/config/type_https_url.go

@@ -0,0 +1,53 @@
+package config
+
+import (
+	"fmt"
+	"net/url"
+)
+
+type TypeHttpsURL struct {
+	Value *url.URL
+}
+
+func (t *TypeHttpsURL) Set(value string) error {
+	parsedURL, err := url.Parse(value)
+	if err != nil {
+		return fmt.Errorf("value is not correct URL (%s): %w", value, err)
+	}
+
+	if parsedURL.Host == "" {
+		return fmt.Errorf("url has to have a schema: %s", value)
+	}
+
+	if parsedURL.Scheme != "https" {
+		return fmt.Errorf("unsupported schema: %s", parsedURL.Scheme)
+	}
+
+	t.Value = parsedURL
+
+	return nil
+}
+
+func (t *TypeHttpsURL) Get(defaultValue *url.URL) *url.URL {
+	if t.Value == nil {
+		return defaultValue
+	}
+
+	return t.Value
+}
+
+func (t *TypeHttpsURL) UnmarshalText(data []byte) error {
+	return t.Set(string(data))
+}
+
+func (t TypeHttpsURL) MarshalText() ([]byte, error) {
+	return []byte(t.String()), nil
+}
+
+func (t TypeHttpsURL) String() string {
+	if t.Value == nil {
+		return ""
+	}
+
+	return t.Value.String()
+}

internal/config/type_https_url_test.go

@@ -0,0 +1,100 @@
+package config_test
+
+import (
+	"encoding/json"
+	"net/url"
+	"testing"
+
+	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+)
+
+type typeHttpsURLTestStruct struct {
+	Value config.TypeHttpsURL `json:"value"`
+}
+
+type HttpsURLTestSuite struct {
+	suite.Suite
+}
+
+func (suite *HttpsURLTestSuite) TestUnmarshalFail() {
+	testData := []string{
+		"",
+		"https://",
+		"://lala",
+		"/path",
+		"http://example.com",
+		"socks5://example.com",
+	}
+
+	for _, v := range testData {
+		data, err := json.Marshal(map[string]string{
+			"value": v,
+		})
+		suite.NoError(err)
+
+		suite.T().Run(v, func(t *testing.T) {
+			assert.Error(t, json.Unmarshal(data, &typeHttpsURLTestStruct{}))
+		})
+	}
+}
+
+func (suite *HttpsURLTestSuite) TestUnmarshalOk() {
+	testData := map[string]string{
+		"https://example.com":           "https://example.com",
+		"https://example.com:8443":      "https://example.com:8443",
+		"https://example.com/path?q=1":  "https://example.com/path?q=1",
+		"https://user:pass@example.com": "https://user:pass@example.com",
+	}
+
+	for k, v := range testData {
+		value := v
+
+		data, err := json.Marshal(map[string]string{
+			"value": k,
+		})
+		suite.NoError(err)
+
+		suite.T().Run(k, func(t *testing.T) {
+			testStruct := &typeHttpsURLTestStruct{}
+			assert.NoError(t, json.Unmarshal(data, testStruct))
+
+			parsed, _ := url.Parse(value)
+
+			assert.Equal(t, parsed.Scheme, testStruct.Value.Get(nil).Scheme)
+			assert.Equal(t, parsed.Host, testStruct.Value.Get(nil).Host)
+			assert.Equal(t, parsed.RawQuery, testStruct.Value.Get(nil).RawQuery)
+			assert.Equal(t, parsed.Path, testStruct.Value.Get(nil).Path)
+		})
+	}
+}
+
+func (suite *HttpsURLTestSuite) TestMarshalOk() {
+	parsed, _ := url.Parse("https://example.com/path?q=1")
+	testStruct := &typeHttpsURLTestStruct{
+		Value: config.TypeHttpsURL{
+			Value: parsed,
+		},
+	}
+
+	encodedJSON, err := json.Marshal(testStruct)
+	suite.NoError(err)
+	suite.JSONEq(`{"value": "https://example.com/path?q=1"}`,
+		string(encodedJSON))
+}
+
+func (suite *HttpsURLTestSuite) TestGet() {
+	emptyURL := &url.URL{}
+
+	value := config.TypeHttpsURL{}
+	suite.Equal(emptyURL, value.Get(emptyURL))
+
+	value.Value = &url.URL{}
+	suite.Equal(value.Value, value.Get(emptyURL))
+}
+
+func TestTypeHttpsURL(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &HttpsURLTestSuite{})
+}

internal/config/type_proxy_url.go

@@ -15,20 +15,24 @@ type TypeProxyURL struct {
 func (t *TypeProxyURL) Set(value string) error {
 	parsedURL, err := url.Parse(value)
 	if err != nil {
-		return fmt.Errorf("value is not corect URL (%s): %w", value, err)
+		return fmt.Errorf("value is not correct URL (%s): %w", value, err)
 	}
 
 	if parsedURL.Host == "" {
 		return fmt.Errorf("url has to have a schema: %s", value)
 	}
 
-	if parsedURL.Scheme != "socks5" {
+	switch parsedURL.Scheme {
+	case "socks5", "socks5h":
+	default:
 		return fmt.Errorf("unsupported schema: %s", parsedURL.Scheme)
 	}
 
 	if _, _, err := net.SplitHostPort(parsedURL.Host); err != nil {
-		parsedURL.Host = net.JoinHostPort(parsedURL.Host,
-			typeProxyURLDefaultSOCKS5Port)
+		parsedURL.Host = net.JoinHostPort(
+			parsedURL.Host,
+			typeProxyURLDefaultSOCKS5Port,
+		)
 	}
 
 	t.Value = parsedURL

internal/proxyprotocol/adapter.go

@@ -0,0 +1,20 @@
+package proxyprotocol
+
+import (
+	"net"
+
+	"github.com/pires/go-proxyproto"
+)
+
+type ListenerAdapter struct {
+	proxyproto.Listener
+}
+
+func (l *ListenerAdapter) Accept() (net.Conn, error) {
+	conn, err := l.Listener.Accept()
+	if err != nil {
+		return nil, err
+	}
+
+	return connWrapper{conn.(*proxyproto.Conn)}, nil
+}

internal/proxyprotocol/conn.go

@@ -0,0 +1,25 @@
+package proxyprotocol
+
+import "github.com/pires/go-proxyproto"
+
+type connWrapper struct {
+	*proxyproto.Conn
+}
+
+func (c connWrapper) CloseRead() error {
+	tcpConn, ok := c.TCPConn()
+	if !ok {
+		panic("we support only tcp connections")
+	}
+
+	return tcpConn.CloseRead()
+}
+
+func (c connWrapper) CloseWrite() error {
+	tcpConn, ok := c.TCPConn()
+	if !ok {
+		panic("we support only tcp connections")
+	}
+
+	return tcpConn.CloseWrite()
+}

internal/testlib/mtglib_network_mock.go

@@ -2,6 +2,7 @@ package testlib
 
 import (
 	"context"
+	"net"
 	"net/http"
 
 	"github.com/9seconds/mtg/v2/essentials"
@@ -24,6 +25,10 @@ func (m *MtglibNetworkMock) DialContext(ctx context.Context, network, address st
 	return args.Get(0).(essentials.Conn), args.Error(1) //nolint: wrapcheck, forcetypeassert
 }
 
+func (m *MtglibNetworkMock) NativeDialer() *net.Dialer {
+	return m.Called().Get(0).(*net.Dialer)
+}
+
 func (m *MtglibNetworkMock) MakeHTTPClient(dialFunc func(ctx context.Context,
 	network, address string) (essentials.Conn, error),
 ) *http.Client {

ipblocklist/files/http.go

@@ -23,7 +23,7 @@ func (h httpFile) Open(ctx context.Context) (io.ReadCloser, error) {
 	if err != nil {
 		if response != nil {
 			io.Copy(io.Discard, response.Body) //nolint: errcheck
-			response.Body.Close() //nolint: errcheck
+			response.Body.Close()              //nolint: errcheck
 		}
 
 		return nil, fmt.Errorf("cannot get url %s: %w", h.url, err)

ipblocklist/firehol.go

@@ -112,18 +112,15 @@ func (f *Firehol) update() {
 	defer cancel()
 
 	wg := &sync.WaitGroup{}
-	wg.Add(len(f.blocklists))
 
 	mutex := &sync.Mutex{}
 	ranger := cidranger.NewPCTrieRanger()
 
 	for _, v := range f.blocklists {
-		go func(file files.File) {
-			defer wg.Done()
+		wg.Go(func() {
+			logger := f.logger.BindStr("filename", v.String())
 
-			logger := f.logger.BindStr("filename", file.String())
-
-			fileContent, err := file.Open(ctx)
+			fileContent, err := v.Open(ctx)
 			if err != nil {
 				logger.WarningError("update has failed", err)
 
@@ -135,7 +132,7 @@ func (f *Firehol) update() {
 			if err := f.updateFromFile(mutex, ranger, bufio.NewScanner(fileContent)); err != nil {
 				logger.WarningError("update has failed", err)
 			}
-		}(v)
+		})
 	}
 
 	wg.Wait()

logger/init.go

@@ -8,5 +8,5 @@ package logger
 // commonly used by many 3pp tools. While mtglib itself does not need it, it is
 // always a good idea to support it and have a transient end to end logging.
 type StdLikeLogger interface {
-	Printf(format string, args ...interface{})
+	Printf(format string, args ...any)
 }

logger/noop.go

@@ -8,7 +8,7 @@ func (n noopLogger) Named(_ string) mtglib.Logger          { return n }
 func (n noopLogger) BindInt(_ string, _ int) mtglib.Logger { return n }
 func (n noopLogger) BindStr(_, _ string) mtglib.Logger     { return n }
 func (n noopLogger) BindJSON(_, _ string) mtglib.Logger    { return n }
-func (n noopLogger) Printf(_ string, _ ...interface{})     {}
+func (n noopLogger) Printf(_ string, _ ...any)             {}
 func (n noopLogger) Info(_ string)                         {}
 func (n noopLogger) Warning(_ string)                      {}
 func (n noopLogger) Debug(_ string)                        {}

logger/zerolog.go

@@ -78,7 +78,7 @@ func (z *zeroLogContext) BindJSON(name, value string) mtglib.Logger {
 	}
 }
 
-func (z *zeroLogContext) Printf(format string, args ...interface{}) {
+func (z *zeroLogContext) Printf(format string, args ...any) {
 	z.Debug(fmt.Sprintf(format, args...))
 }
 

main.go

@@ -14,6 +14,23 @@ import (
 )
 
 func main() {
+	// this runs profiling server. To enable it, build with prof tag
+	//   $ go build -tags prof
+	//
+	// Then you can pass a port using MTG_PROF_PORT environment variable.
+	// Default is 6000
+	//   $ MTG_PROF_PORT=6000 mtg run config.toml
+	//
+	// It will run a webserver with profiling data on
+	// localhost:${MTG_PROF_PORT:-6000}.
+	//
+	// To collect PGO do following:
+	//   $ curl -o default.pgo 'http://localhost:6000/debug/pprof/profile?seconds=300'
+	//
+	// See also https://pkg.go.dev/net/http/pprof
+	//          https://go.dev/blog/pprof
+	runProfile()
+
 	cli := &cli.CLI{}
 	ctx := kong.Parse(cli, kong.Vars{
 		"version": getVersion(),

mise.lock

@@ -0,0 +1,121 @@
+# @generated - this file is auto-generated by `mise lock` https://mise.jdx.dev/dev-tools/mise-lock.html
+
+[[tools.go]]
+version = "1.26.1"
+backend = "core:go"
+
+[tools.go."platforms.linux-arm64"]
+checksum = "sha256:a290581cfe4fe28ddd737dde3095f3dbeb7f2e4065cab4eae44dfc53b760c2f7"
+url = "https://dl.google.com/go/go1.26.1.linux-arm64.tar.gz"
+
+[tools.go."platforms.linux-arm64-musl"]
+checksum = "sha256:a290581cfe4fe28ddd737dde3095f3dbeb7f2e4065cab4eae44dfc53b760c2f7"
+url = "https://dl.google.com/go/go1.26.1.linux-arm64.tar.gz"
+
+[tools.go."platforms.linux-x64"]
+checksum = "sha256:031f088e5d955bab8657ede27ad4e3bc5b7c1ba281f05f245bcc304f327c987a"
+url = "https://dl.google.com/go/go1.26.1.linux-amd64.tar.gz"
+
+[tools.go."platforms.linux-x64-musl"]
+checksum = "sha256:031f088e5d955bab8657ede27ad4e3bc5b7c1ba281f05f245bcc304f327c987a"
+url = "https://dl.google.com/go/go1.26.1.linux-amd64.tar.gz"
+
+[tools.go."platforms.macos-arm64"]
+checksum = "sha256:353df43a7811ce284c8938b5f3c7df40b7bfb6f56cb165b150bc40b5e2dd541f"
+url = "https://dl.google.com/go/go1.26.1.darwin-arm64.tar.gz"
+
+[tools.go."platforms.macos-x64"]
+checksum = "sha256:65773dab2f8cc4cd23d93ba6d0a805de150ca0b78378879292be0b903b8cdd08"
+url = "https://dl.google.com/go/go1.26.1.darwin-amd64.tar.gz"
+
+[tools.go."platforms.windows-x64"]
+checksum = "sha256:9b68112c913f45b7aebbf13c036721264bbba7e03a642f8f7490c561eebd1ecc"
+url = "https://dl.google.com/go/go1.26.1.windows-amd64.zip"
+
+[[tools."go:golang.org/x/pkgsite/cmd/pkgsite"]]
+version = "latest"
+backend = "go:golang.org/x/pkgsite/cmd/pkgsite"
+
+[[tools."go:golang.org/x/tools/gopls"]]
+version = "0.21.1"
+backend = "go:golang.org/x/tools/gopls"
+
+[[tools."go:golang.org/x/vuln/cmd/govulncheck"]]
+version = "1.1.4"
+backend = "go:golang.org/x/vuln/cmd/govulncheck"
+
+[[tools."go:mvdan.cc/gofumpt"]]
+version = "0.9.2"
+backend = "go:mvdan.cc/gofumpt"
+
+[[tools.golangci-lint]]
+version = "2.11.4"
+backend = "aqua:golangci/golangci-lint"
+
+[tools.golangci-lint."platforms.linux-arm64"]
+checksum = "sha256:3bcfa2e6f3d32b2bf5cd75eaa876447507025e0303698633f722a05331988db4"
+url = "https://github.com/golangci/golangci-lint/releases/download/v2.11.4/golangci-lint-2.11.4-linux-arm64.tar.gz"
+
+[tools.golangci-lint."platforms.linux-arm64-musl"]
+checksum = "sha256:3bcfa2e6f3d32b2bf5cd75eaa876447507025e0303698633f722a05331988db4"
+url = "https://github.com/golangci/golangci-lint/releases/download/v2.11.4/golangci-lint-2.11.4-linux-arm64.tar.gz"
+
+[tools.golangci-lint."platforms.linux-x64"]
+checksum = "sha256:200c5b7503f67b59a6743ccf32133026c174e272b930ee79aa2aa6f37aca7ef1"
+url = "https://github.com/golangci/golangci-lint/releases/download/v2.11.4/golangci-lint-2.11.4-linux-amd64.tar.gz"
+
+[tools.golangci-lint."platforms.linux-x64-musl"]
+checksum = "sha256:200c5b7503f67b59a6743ccf32133026c174e272b930ee79aa2aa6f37aca7ef1"
+url = "https://github.com/golangci/golangci-lint/releases/download/v2.11.4/golangci-lint-2.11.4-linux-amd64.tar.gz"
+
+[tools.golangci-lint."platforms.macos-arm64"]
+checksum = "sha256:02db2a2dae8b26812e53b0688a6f617e3ef1f489790e829ea22862cf76945675"
+url = "https://github.com/golangci/golangci-lint/releases/download/v2.11.4/golangci-lint-2.11.4-darwin-arm64.tar.gz"
+provenance = "github-attestations"
+
+[tools.golangci-lint."platforms.macos-x64"]
+checksum = "sha256:c900d4048db75d1edfd550fd11cf6a9b3008e7caa8e119fcddbc700412d63e60"
+url = "https://github.com/golangci/golangci-lint/releases/download/v2.11.4/golangci-lint-2.11.4-darwin-amd64.tar.gz"
+
+[tools.golangci-lint."platforms.windows-x64"]
+checksum = "sha256:4932cfca5e75bf60fe1c576edf459e5e809e6644664a068185d64b84af3fad9e"
+url = "https://github.com/golangci/golangci-lint/releases/download/v2.11.4/golangci-lint-2.11.4-windows-amd64.zip"
+
+[[tools.goreleaser]]
+version = "2.15.2"
+backend = "aqua:goreleaser/goreleaser"
+
+[tools.goreleaser."platforms.linux-arm64"]
+checksum = "sha256:5db66761a98f6693161e49e1a95d28d2673a892ba60cb4a5e16736cafd41c4c9"
+url = "https://github.com/goreleaser/goreleaser/releases/download/v2.15.2/goreleaser_Linux_arm64.tar.gz"
+provenance = "cosign"
+
+[tools.goreleaser."platforms.linux-arm64-musl"]
+checksum = "sha256:5db66761a98f6693161e49e1a95d28d2673a892ba60cb4a5e16736cafd41c4c9"
+url = "https://github.com/goreleaser/goreleaser/releases/download/v2.15.2/goreleaser_Linux_arm64.tar.gz"
+provenance = "cosign"
+
+[tools.goreleaser."platforms.linux-x64"]
+checksum = "sha256:0ebdbf0353aba566b969dde746cc4e4806f96c27aa2f3971b229a9df7611fedc"
+url = "https://github.com/goreleaser/goreleaser/releases/download/v2.15.2/goreleaser_Linux_x86_64.tar.gz"
+provenance = "cosign"
+
+[tools.goreleaser."platforms.linux-x64-musl"]
+checksum = "sha256:0ebdbf0353aba566b969dde746cc4e4806f96c27aa2f3971b229a9df7611fedc"
+url = "https://github.com/goreleaser/goreleaser/releases/download/v2.15.2/goreleaser_Linux_x86_64.tar.gz"
+provenance = "cosign"
+
+[tools.goreleaser."platforms.macos-arm64"]
+checksum = "sha256:0e6bd67688ac949780bf1166813a91f89856898ef4c40d7d46c2c74ebaa4b9ee"
+url = "https://github.com/goreleaser/goreleaser/releases/download/v2.15.2/goreleaser_Darwin_all.tar.gz"
+provenance = "github-attestations"
+
+[tools.goreleaser."platforms.macos-x64"]
+checksum = "sha256:0e6bd67688ac949780bf1166813a91f89856898ef4c40d7d46c2c74ebaa4b9ee"
+url = "https://github.com/goreleaser/goreleaser/releases/download/v2.15.2/goreleaser_Darwin_all.tar.gz"
+provenance = "cosign"
+
+[tools.goreleaser."platforms.windows-x64"]
+checksum = "sha256:7459832946dbe122c144f8d7f87484d8572ca005b779310aa6bb03346e8de17a"
+url = "https://github.com/goreleaser/goreleaser/releases/download/v2.15.2/goreleaser_Windows_x86_64.zip"
+provenance = "cosign"

mtglib/conns.go

@@ -3,10 +3,15 @@ package mtglib
 import (
 	"bytes"
 	"context"
+	"errors"
+	"fmt"
 	"io"
-	"sync"
+	"net"
+	"sync/atomic"
+	"time"
 
 	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/pires/go-proxyproto"
 )
 
 type connTraffic struct {
@@ -40,22 +45,15 @@ func (c connTraffic) Write(b []byte) (int, error) {
 type connRewind struct {
 	essentials.Conn
 
-	active io.Reader
 	buf    bytes.Buffer
-	mutex  sync.RWMutex
+	active io.Reader
 }
 
 func (c *connRewind) Read(p []byte) (int, error) {
-	c.mutex.RLock()
-	defer c.mutex.RUnlock()
-
-	return c.active.Read(p) //nolint: wrapcheck
+	return c.active.Read(p)
 }
 
 func (c *connRewind) Rewind() {
-	c.mutex.Lock()
-	defer c.mutex.Unlock()
-
 	c.active = io.MultiReader(&c.buf, c.Conn)
 }
 
@@ -67,3 +65,97 @@ func newConnRewind(conn essentials.Conn) *connRewind {
 
 	return rv
 }
+
+type connProxyProtocol struct {
+	essentials.Conn
+
+	sourceAddr     net.Addr
+	headersWritten bool
+}
+
+func (c *connProxyProtocol) Write(p []byte) (int, error) {
+	if !c.headersWritten {
+		headers := proxyproto.HeaderProxyFromAddrs(2, c.sourceAddr, c.RemoteAddr())
+
+		toSend, err := headers.Format()
+		if err != nil {
+			panic(err)
+		}
+
+		if _, err := c.Conn.Write(toSend); err != nil {
+			return 0, fmt.Errorf("cannot send proxy protocol header: %w", err)
+		}
+
+		c.headersWritten = true
+	}
+
+	return c.Conn.Write(p)
+}
+
+func newConnProxyProtocol(source, target essentials.Conn) *connProxyProtocol {
+	return &connProxyProtocol{
+		Conn:       target,
+		sourceAddr: source.RemoteAddr(),
+	}
+}
+
+// idleTracker is a shared idle tracker for a pair of relay connections.
+// Both directions update the same timestamp so that activity in one direction
+// prevents the other (idle) direction from timing out.
+type idleTracker struct {
+	lastActive atomic.Pointer[time.Time]
+	timeout    time.Duration
+}
+
+func newIdleTracker(timeout time.Duration) *idleTracker {
+	t := &idleTracker{timeout: timeout}
+	t.touch()
+
+	return t
+}
+
+func (t *idleTracker) touch() {
+	stamp := time.Now()
+	t.lastActive.Store(&stamp)
+}
+
+func (t *idleTracker) isIdle() bool {
+	return time.Since(*t.lastActive.Load()) >= t.timeout
+}
+
+type connIdleTimeout struct {
+	essentials.Conn
+
+	tracker *idleTracker
+}
+
+func (c connIdleTimeout) Read(b []byte) (int, error) {
+	var netErr net.Error
+
+	for {
+		c.SetReadDeadline(time.Now().Add(c.tracker.timeout)) //nolint: errcheck
+
+		n, err := c.Conn.Read(b)
+
+		switch {
+		case err == nil:
+			c.tracker.touch()
+			return n, nil
+		case errors.As(err, &netErr) && netErr.Timeout() && !c.tracker.isIdle():
+			continue
+		}
+
+		return n, err
+	}
+}
+
+func (c connIdleTimeout) Write(b []byte) (int, error) {
+	c.SetWriteDeadline(time.Now().Add(c.tracker.timeout)) //nolint: errcheck
+
+	n, err := c.Conn.Write(b)
+	if n > 0 {
+		c.tracker.touch()
+	}
+
+	return n, err //nolint: wrapcheck
+}

mtglib/conns_internal_test.go

@@ -1,18 +1,27 @@
 package mtglib
 
 import (
+	"bufio"
 	"bytes"
 	"context"
 	"errors"
 	"io"
+	"net"
 	"testing"
 	"time"
 
 	"github.com/9seconds/mtg/v2/internal/testlib"
+	"github.com/pires/go-proxyproto"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 )
 
+type netTimeoutError struct{}
+
+func (e netTimeoutError) Error() string   { return "i/o timeout" }
+func (e netTimeoutError) Timeout() bool   { return true }
+func (e netTimeoutError) Temporary() bool { return true }
+
 type ConnRewindBaseConn struct {
 	testlib.EssentialsConnMock
 
@@ -200,6 +209,229 @@ func (suite *ConnRewindTestSuite) TestRead() {
 	suite.Equal([]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, data)
 }
 
+type ConnProxyProtocolTestSuite struct {
+	suite.Suite
+
+	sourceConnMock *testlib.EssentialsConnMock
+	targetConnMock *testlib.EssentialsConnMock
+	conn           *connProxyProtocol
+}
+
+func (suite *ConnProxyProtocolTestSuite) SetupTest() {
+	suite.sourceConnMock = &testlib.EssentialsConnMock{}
+	suite.targetConnMock = &testlib.EssentialsConnMock{}
+
+	localAddr := &net.TCPAddr{
+		IP: net.ParseIP("127.0.0.1").To4(),
+	}
+	remoteAddr := &net.TCPAddr{
+		IP: net.ParseIP("127.0.0.2").To4(),
+	}
+
+	suite.sourceConnMock.
+		On("RemoteAddr").
+		Return(localAddr)
+	suite.targetConnMock.
+		On("RemoteAddr").
+		Maybe().
+		Return(remoteAddr)
+
+	suite.conn = newConnProxyProtocol(suite.sourceConnMock, suite.targetConnMock)
+}
+
+func (suite *ConnProxyProtocolTestSuite) TestRead() {
+	value := []byte{1, 2, 3, 4, 5}
+	toRead := make([]byte, len(value))
+
+	suite.targetConnMock.
+		On("Read", mock.AnythingOfType("[]uint8")).
+		Once().
+		Return(len(toRead), nil).
+		Run(func(args mock.Arguments) {
+			arr := args.Get(0).([]byte)
+			copy(arr, value)
+		})
+
+	n, err := suite.conn.Read(toRead)
+	suite.Equal(len(value), n)
+	suite.NoError(err)
+	suite.Equal(value, toRead)
+}
+
+func (suite *ConnProxyProtocolTestSuite) TestWrite() {
+	value := []byte{1, 2, 3, 4, 5}
+	buf := &bytes.Buffer{}
+	bufReader := bufio.NewReader(buf)
+
+	suite.targetConnMock.
+		On("Write", mock.AnythingOfType("[]uint8")).
+		Return(28, nil).
+		Run(func(args mock.Arguments) {
+			arr := args.Get(0).([]byte)
+			buf.Write(arr)
+		})
+
+	_, err := suite.conn.Write(value)
+	suite.NoError(err)
+
+	header, err := proxyproto.Read(bufReader)
+	suite.NoError(err)
+
+	sourceAddr, destAddr, ok := header.TCPAddrs()
+	suite.True(ok)
+	suite.Equal(suite.sourceConnMock.RemoteAddr(), sourceAddr)
+	suite.Equal(suite.targetConnMock.RemoteAddr(), destAddr)
+
+	read, _ := io.ReadAll(bufReader)
+	suite.Equal(value, read)
+
+	_, err = suite.conn.Write(value)
+	suite.NoError(err)
+
+	read, _ = io.ReadAll(bufReader)
+	suite.Equal(value, read)
+}
+
+func (suite *ConnProxyProtocolTestSuite) TearDownTest() {
+	suite.sourceConnMock.AssertExpectations(suite.T())
+	suite.targetConnMock.AssertExpectations(suite.T())
+}
+
+type IdleTrackerTestSuite struct {
+	suite.Suite
+}
+
+func (suite *IdleTrackerTestSuite) TestNewNotIdle() {
+	tracker := newIdleTracker(time.Second)
+	suite.False(tracker.isIdle())
+}
+
+func (suite *IdleTrackerTestSuite) TestIdleAfterTimeout() {
+	tracker := newIdleTracker(10 * time.Millisecond)
+	time.Sleep(20 * time.Millisecond)
+
+	suite.True(tracker.isIdle())
+}
+
+func (suite *IdleTrackerTestSuite) TestTouchResetsIdle() {
+	tracker := newIdleTracker(50 * time.Millisecond)
+	time.Sleep(30 * time.Millisecond)
+
+	tracker.touch()
+
+	suite.False(tracker.isIdle())
+}
+
+type ConnIdleTimeoutTestSuite struct {
+	suite.Suite
+
+	connMock *testlib.EssentialsConnMock
+	tracker  *idleTracker
+	conn     connIdleTimeout
+}
+
+func (suite *ConnIdleTimeoutTestSuite) SetupTest() {
+	suite.connMock = &testlib.EssentialsConnMock{}
+	suite.tracker = newIdleTracker(time.Second)
+	suite.conn = connIdleTimeout{
+		Conn:    suite.connMock,
+		tracker: suite.tracker,
+	}
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TearDownTest() {
+	suite.connMock.AssertExpectations(suite.T())
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestReadOk() {
+	suite.connMock.On("SetReadDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Read", mock.Anything).Once().Return(5, nil)
+
+	n, err := suite.conn.Read(make([]byte, 10))
+	suite.NoError(err)
+	suite.Equal(5, n)
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestReadNonTimeoutErr() {
+	suite.connMock.On("SetReadDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Read", mock.Anything).Once().Return(0, io.EOF)
+
+	n, err := suite.conn.Read(make([]byte, 10))
+	suite.True(errors.Is(err, io.EOF))
+	suite.Equal(0, n)
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestReadTimeoutRetriesWhenNotIdle() {
+	suite.connMock.On("SetReadDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Read", mock.Anything).Once().Return(0, netTimeoutError{})
+	suite.connMock.On("Read", mock.Anything).Once().Return(5, nil)
+
+	n, err := suite.conn.Read(make([]byte, 10))
+	suite.NoError(err)
+	suite.Equal(5, n)
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestReadTimeoutClosesWhenIdle() {
+	suite.tracker = newIdleTracker(time.Millisecond)
+	suite.conn = connIdleTimeout{
+		Conn:    suite.connMock,
+		tracker: suite.tracker,
+	}
+
+	time.Sleep(5 * time.Millisecond)
+
+	suite.connMock.On("SetReadDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Read", mock.Anything).Once().Return(0, netTimeoutError{})
+
+	n, err := suite.conn.Read(make([]byte, 10))
+	suite.Equal(0, n)
+
+	netErr, ok := err.(net.Error) //nolint: errorlint
+	suite.True(ok)
+	suite.True(netErr.Timeout())
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestSharedTrackerPreventsFalseTimeout() {
+	connMock2 := &testlib.EssentialsConnMock{}
+	conn2 := connIdleTimeout{
+		Conn:    connMock2,
+		tracker: suite.tracker,
+	}
+
+	connMock2.On("SetWriteDeadline", mock.Anything).Return(nil)
+	connMock2.On("Write", mock.Anything).Once().Return(5, nil)
+
+	_, _ = conn2.Write(make([]byte, 5))
+
+	suite.connMock.On("SetReadDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Read", mock.Anything).Once().Return(0, netTimeoutError{})
+	suite.connMock.On("Read", mock.Anything).Once().Return(3, nil)
+
+	n, err := suite.conn.Read(make([]byte, 10))
+	suite.NoError(err)
+	suite.Equal(3, n)
+
+	connMock2.AssertExpectations(suite.T())
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestWriteOk() {
+	suite.connMock.On("SetWriteDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Write", mock.Anything).Once().Return(5, nil)
+
+	n, err := suite.conn.Write(make([]byte, 5))
+	suite.NoError(err)
+	suite.Equal(5, n)
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestWriteErr() {
+	suite.connMock.On("SetWriteDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Write", mock.Anything).Once().Return(0, io.EOF)
+
+	n, err := suite.conn.Write(make([]byte, 5))
+	suite.True(errors.Is(err, io.EOF))
+	suite.Equal(0, n)
+}
+
 func TestConnTraffic(t *testing.T) {
 	t.Parallel()
 	suite.Run(t, &ConnTrafficTestSuite{})
@@ -209,3 +441,18 @@ func TestConnRewind(t *testing.T) {
 	t.Parallel()
 	suite.Run(t, &ConnRewindTestSuite{})
 }
+
+func TestConnProxyProtocol(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &ConnProxyProtocolTestSuite{})
+}
+
+func TestIdleTracker(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &IdleTrackerTestSuite{})
+}
+
+func TestConnIdleTimeout(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &ConnIdleTimeoutTestSuite{})
+}

mtglib/init.go

@@ -99,6 +99,13 @@ const (
 	// reads from Telegram after which connection will be terminated. This is
 	// required to abort stale connections.
 	TCPRelayReadTimeout = 20 * time.Second
+
+	// DoppelGangerPerRaid defines a number of requests to each URL
+	// per raid.
+	DoppelGangerPerRaid = 10
+
+	// DoppelGangerEach defines a time period between each crawl attempt.
+	DoppelGangerEach = 6 * time.Hour
 )
 
 // Network defines a knowledge how to work with a network. It may sound fun but
@@ -117,13 +124,17 @@ type Network interface {
 	// Dial establishes context-free TCP connections.
 	Dial(network, address string) (essentials.Conn, error)
 
-	// DialContext dials using a context. This is a preferrable way of
+	// DialContext dials using a context. This is a preferable way of
 	// establishing TCP connections.
 	DialContext(ctx context.Context, network, address string) (essentials.Conn, error)
 
 	// MakeHTTPClient build an HTTP client with given dial function. If nothing is
 	// provided, then DialContext of this interface is going to be used.
 	MakeHTTPClient(func(ctx context.Context, network, address string) (essentials.Conn, error)) *http.Client
+
+	// NativeDialer returns a configured instance of native dialer that
+	// skips proxy connections or any other irrelevant settings.
+	NativeDialer() *net.Dialer
 }
 
 // AntiReplayCache is an interface that is used to detect replay attacks based
@@ -249,7 +260,7 @@ type Logger interface {
 	BindJSON(name, value string) Logger
 
 	// Printf is to support log.Logger behavior.
-	Printf(format string, args ...interface{})
+	Printf(format string, args ...any)
 
 	// Info puts a message about some normal situation.
 	Info(msg string)

mtglib/init_internal_test.go

@@ -8,17 +8,17 @@ import (
 
 type NoopLogger struct{}
 
-func (n NoopLogger) Named(_ string) Logger             { return n }
-func (n NoopLogger) BindInt(_ string, _ int) Logger    { return n }
-func (n NoopLogger) BindStr(_, _ string) Logger        { return n }
-func (n NoopLogger) BindJSON(_, _ string) Logger       { return n }
-func (n NoopLogger) Printf(_ string, _ ...interface{}) {}
-func (n NoopLogger) Info(_ string)                     {}
-func (n NoopLogger) Warning(_ string)                  {}
-func (n NoopLogger) Debug(_ string)                    {}
-func (n NoopLogger) InfoError(_ string, _ error)       {}
-func (n NoopLogger) WarningError(_ string, _ error)    {}
-func (n NoopLogger) DebugError(_ string, _ error)      {}
+func (n NoopLogger) Named(_ string) Logger          { return n }
+func (n NoopLogger) BindInt(_ string, _ int) Logger { return n }
+func (n NoopLogger) BindStr(_, _ string) Logger     { return n }
+func (n NoopLogger) BindJSON(_, _ string) Logger    { return n }
+func (n NoopLogger) Printf(_ string, _ ...any)      {}
+func (n NoopLogger) Info(_ string)                  {}
+func (n NoopLogger) Warning(_ string)               {}
+func (n NoopLogger) Debug(_ string)                 {}
+func (n NoopLogger) InfoError(_ string, _ error)    {}
+func (n NoopLogger) WarningError(_ string, _ error) {}
+func (n NoopLogger) DebugError(_ string, _ error)   {}
 
 type EventStreamMock struct {
 	mock.Mock

mtglib/internal/dc/addr.go

@@ -0,0 +1,17 @@
+package dc
+
+import (
+	"fmt"
+
+	"github.com/9seconds/mtg/v2/mtglib/internal/obfuscation"
+)
+
+type Addr struct {
+	Network    string
+	Address    string
+	Obfuscator obfuscation.Obfuscator
+}
+
+func (d Addr) String() string {
+	return fmt.Sprintf("addr=%s, secret=%v", d.Address, d.Obfuscator.Secret)
+}

mtglib/internal/dc/addr_set.go

@@ -0,0 +1,33 @@
+package dc
+
+import "math/rand/v2"
+
+type dcAddrSet struct {
+	v4 map[int][]Addr
+	v6 map[int][]Addr
+}
+
+func (d dcAddrSet) getV4(dc int) []Addr {
+	if d.v4 == nil {
+		return nil
+	}
+	return d.get(d.v4[dc])
+}
+
+func (d dcAddrSet) getV6(dc int) []Addr {
+	if d.v6 == nil {
+		return nil
+	}
+	return d.get(d.v6[dc])
+}
+
+func (d dcAddrSet) get(addrs []Addr) []Addr {
+	otherSet := make([]Addr, 0, len(addrs))
+	otherSet = append(otherSet, addrs...)
+
+	rand.Shuffle(len(otherSet), func(i, j int) {
+		otherSet[i], otherSet[j] = otherSet[j], otherSet[i]
+	})
+
+	return otherSet
+}

mtglib/internal/dc/init.go

@@ -0,0 +1,77 @@
+package dc
+
+import (
+	"context"
+	"net"
+	"time"
+
+	"github.com/9seconds/mtg/v2/essentials"
+)
+
+type preferIP uint8
+
+const (
+	preferIPOnlyIPv4 preferIP = iota
+	preferIPOnlyIPv6
+	preferIPPreferIPv4
+	preferIPPreferIPv6
+)
+
+const (
+	// Default DC to connect to if not sure.
+	DefaultDC = 2
+
+	// How often should we request updates from
+	// https://core.telegram.org/getProxyConfig
+	PublicConfigUpdateEach  = time.Hour
+	PublicConfigUpdateURLv4 = "https://core.telegram.org/getProxyConfig"
+	PublicConfigUpdateURLv6 = "https://core.telegram.org/getProxyConfigV6"
+
+	// How often should we extract hosts from Telegram using help.getConfig
+	// method.
+	OwnConfigUpdateEach = time.Hour
+)
+
+type Logger interface {
+	Info(msg string)
+	WarningError(msg string, err error)
+}
+
+type Updater interface {
+	Run(ctx context.Context)
+}
+
+// https://github.com/telegramdesktop/tdesktop/blob/master/Telegram/SourceFiles/mtproto/mtproto_dc_options.cpp#L30
+var defaultDCAddrSet = (func() dcAddrSet {
+	addrSet := dcAddrSet{
+		v4: make(map[int][]Addr),
+		v6: make(map[int][]Addr),
+	}
+
+	for dcid, ips := range essentials.TelegramCoreAddresses {
+		for _, addr := range ips {
+			host, _, err := net.SplitHostPort(addr)
+			if err != nil {
+				panic(err)
+			}
+
+			ip := net.ParseIP(host)
+			if ip == nil {
+				panic(addr)
+			}
+			if ip.To4() == nil {
+				addrSet.v6[dcid] = append(addrSet.v6[dcid], Addr{
+					Network: "tcp6",
+					Address: addr,
+				})
+			} else {
+				addrSet.v4[dcid] = append(addrSet.v4[dcid], Addr{
+					Network: "tcp4",
+					Address: addr,
+				})
+			}
+		}
+	}
+
+	return addrSet
+})()

mtglib/internal/dc/init_test.go

@@ -0,0 +1,43 @@
+package dc
+
+import (
+	"context"
+
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+)
+
+type LoggerMock struct {
+	mock.Mock
+}
+
+func (m *LoggerMock) Info(msg string) {
+	m.Called(msg)
+}
+
+func (m *LoggerMock) WarningError(msg string, err error) {
+	m.Called(msg, err)
+}
+
+type UpdaterTestSuiteBase struct {
+	suite.Suite
+
+	ctx        context.Context
+	ctxCancel  context.CancelFunc
+	loggerMock *LoggerMock
+}
+
+func (s *UpdaterTestSuiteBase) SetupTest() {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	s.loggerMock = &LoggerMock{}
+	s.loggerMock.On("Info", mock.AnythingOfType("string"))
+	s.loggerMock.On("WarningError", mock.AnythingOfType("string"), mock.Anything)
+
+	s.ctx = ctx
+	s.ctxCancel = cancel
+}
+
+func (s *UpdaterTestSuiteBase) TearDownTest() {
+	s.ctxCancel()
+}

mtglib/internal/dc/public_config_updater.go

@@ -0,0 +1,93 @@
+package dc
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"strconv"
+)
+
+var publicConfigRe = regexp.MustCompile(`^\s*proxy_for\s+(\d+)\s+(\S+?)?;\s*$`)
+
+type PublicConfigUpdater struct {
+	updater
+
+	http *http.Client
+	tg   *Telegram
+}
+
+func (p *PublicConfigUpdater) Run(ctx context.Context, url, network string) {
+	p.run(ctx, func() error {
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+		if err != nil {
+			panic(err)
+		}
+
+		resp, err := p.http.Do(req)
+		if err != nil {
+			if resp != nil {
+				io.Copy(io.Discard, resp.Body) //nolint: errcheck
+				resp.Body.Close()              //nolint: errcheck
+			}
+			return fmt.Errorf("cannot fetch url %s: %w", url, err)
+		}
+
+		if resp.StatusCode >= http.StatusBadRequest {
+			return fmt.Errorf("unexpected status code from %s: %d", url, resp.StatusCode)
+		}
+
+		scanner := bufio.NewScanner(resp.Body)
+		addrs := map[int][]Addr{}
+
+		for scanner.Scan() {
+			matches := publicConfigRe.FindStringSubmatch(scanner.Text())
+			if len(matches) != 3 {
+				continue
+			}
+
+			dc, err := strconv.Atoi(matches[1])
+			if err != nil {
+				continue
+			}
+
+			switch dc {
+			// this is a list of DC we currently support. Other are ignored.
+			case 203: // CDN DC
+				p.logger.Info(fmt.Sprintf("found %s address for DC %d", matches[2], dc))
+				addrs[dc] = append(addrs[dc], Addr{
+					Network: network,
+					Address: matches[2],
+				})
+			}
+		}
+
+		if err := scanner.Err(); err != nil {
+			return fmt.Errorf("cannot read response body from %s: %w", url, err)
+		}
+
+		p.tg.lock.Lock()
+		defer p.tg.lock.Unlock()
+
+		if network == "tcp4" {
+			p.tg.view.publicConfigs.v4 = addrs
+		} else {
+			p.tg.view.publicConfigs.v6 = addrs
+		}
+
+		return nil
+	})
+}
+
+func NewPublicConfigUpdater(tg *Telegram, logger Logger, client *http.Client) *PublicConfigUpdater {
+	return &PublicConfigUpdater{
+		updater: updater{
+			logger: logger,
+			period: PublicConfigUpdateEach,
+		},
+		http: client,
+		tg:   tg,
+	}
+}

mtglib/internal/dc/public_config_updater_test.go

@@ -0,0 +1,113 @@
+package dc
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+)
+
+type PublicConfigUpdaterTestSuite struct {
+	UpdaterTestSuiteBase
+
+	u               *PublicConfigUpdater
+	lock            sync.Mutex
+	srv             *httptest.Server
+	responseHandler func(w http.ResponseWriter)
+}
+
+func (s *PublicConfigUpdaterTestSuite) SetupSuite() {
+	s.srv = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		s.lock.Lock()
+		s.responseHandler(w)
+		s.lock.Unlock()
+	}))
+}
+
+func (s *PublicConfigUpdaterTestSuite) TearDownSuite() {
+	s.srv.Close()
+}
+
+func (s *PublicConfigUpdaterTestSuite) SetupTest() {
+	s.UpdaterTestSuiteBase.SetupTest()
+
+	tg, err := New("prefer-ipv4")
+	require.NoError(s.T(), err)
+
+	s.u = NewPublicConfigUpdater(tg, s.loggerMock, s.srv.Client())
+}
+
+func (s *PublicConfigUpdaterTestSuite) Test502StatusCode() {
+	s.responseHandler = func(w http.ResponseWriter) {
+		w.WriteHeader(http.StatusBadGateway)
+	}
+	s.u.Run(s.ctx, s.srv.URL, "tcp4")
+
+	time.Sleep(100 * time.Millisecond)
+	s.ctxCancel()
+	s.u.Wait()
+
+	s.Len(s.u.tg.view.publicConfigs.v4, 0)
+}
+
+func (s *PublicConfigUpdaterTestSuite) TestEmptyFile() {
+	s.responseHandler = func(w http.ResponseWriter) {
+		w.WriteHeader(http.StatusOK)
+	}
+	s.u.Run(s.ctx, s.srv.URL, "tcp4")
+
+	time.Sleep(100 * time.Millisecond)
+	s.ctxCancel()
+	s.u.Wait()
+
+	s.Len(s.u.tg.view.publicConfigs.v4, 0)
+}
+
+func (s *PublicConfigUpdaterTestSuite) TestGarbage() {
+	result := `
+proxy_for -1 -1;
+proxy_for 100 100.10.0.0:3333;
+lala 0 0
+`
+
+	s.responseHandler = func(w http.ResponseWriter) {
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte(result)) //nolint: errcheck
+	}
+	s.u.Run(s.ctx, s.srv.URL, "tcp4")
+
+	time.Sleep(100 * time.Millisecond)
+	s.ctxCancel()
+	s.u.Wait()
+
+	s.Len(s.u.tg.view.publicConfigs.v4, 0)
+}
+
+func (s *PublicConfigUpdaterTestSuite) TestOk() {
+	result := `
+proxy_for 203 100.10.0.0:3333;
+proxy_for -100 101.10.0.0:3333;
+`
+
+	s.responseHandler = func(w http.ResponseWriter) {
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte(result)) //nolint: errcheck
+	}
+	s.u.Run(s.ctx, s.srv.URL, "tcp4")
+
+	time.Sleep(100 * time.Millisecond)
+	s.ctxCancel()
+	s.u.Wait()
+
+	s.Len(s.u.tg.view.publicConfigs.v4, 1)
+	s.Len(s.u.tg.view.publicConfigs.v4[203], 1)
+	s.Equal("100.10.0.0:3333", s.u.tg.view.publicConfigs.v4[203][0].Address)
+}
+
+func TestPublicConfigUpdater(t *testing.T) {
+	suite.Run(t, &PublicConfigUpdaterTestSuite{})
+}

mtglib/internal/dc/telegram.go

@@ -0,0 +1,50 @@
+package dc
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+)
+
+type Telegram struct {
+	lock     sync.RWMutex
+	view     dcView
+	preferIP preferIP
+}
+
+func (t *Telegram) GetAddresses(dc int) []Addr {
+	t.lock.RLock()
+	defer t.lock.RUnlock()
+
+	switch t.preferIP {
+	case preferIPOnlyIPv4:
+		return t.view.getV4(dc)
+	case preferIPOnlyIPv6:
+		return t.view.getV6(dc)
+	case preferIPPreferIPv4:
+		return append(t.view.getV4(dc), t.view.getV6(dc)...)
+	}
+
+	return append(t.view.getV6(dc), t.view.getV4(dc)...)
+}
+
+func New(ipPreference string) (*Telegram, error) {
+	var pref preferIP
+
+	switch strings.ToLower(ipPreference) {
+	case "prefer-ipv4":
+		pref = preferIPPreferIPv4
+	case "prefer-ipv6":
+		pref = preferIPPreferIPv6
+	case "only-ipv4":
+		pref = preferIPOnlyIPv4
+	case "only-ipv6":
+		pref = preferIPOnlyIPv6
+	default:
+		return nil, fmt.Errorf("unknown ip preference %s", ipPreference)
+	}
+
+	return &Telegram{
+		preferIP: pref,
+	}, nil
+}

mtglib/internal/dc/updater.go

@@ -0,0 +1,47 @@
+package dc
+
+import (
+	"context"
+	"sync"
+	"time"
+)
+
+type updater struct {
+	wg     sync.WaitGroup
+	logger Logger
+	period time.Duration
+}
+
+func (u *updater) Wait() {
+	u.wg.Wait()
+}
+
+func (u *updater) run(ctx context.Context, callback func() error) {
+	u.wg.Go(func() {
+		ticker := time.NewTicker(u.period)
+
+		defer func() {
+			ticker.Stop()
+
+			select {
+			case <-ticker.C:
+			default:
+			}
+		}()
+
+		for {
+			u.logger.Info("start update")
+			if err := callback(); err != nil {
+				u.logger.WarningError("cannot update", err)
+			}
+			u.logger.Info("updated")
+
+			select {
+			case <-ctx.Done():
+				u.logger.Info("stop updating")
+				return
+			case <-ticker.C:
+			}
+		}
+	})
+}

mtglib/internal/dc/updater_test.go

@@ -0,0 +1,55 @@
+package dc
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/suite"
+)
+
+type UpdaterTestSuite struct {
+	UpdaterTestSuiteBase
+
+	u updater
+}
+
+func (s *UpdaterTestSuite) SetupTest() {
+	s.UpdaterTestSuiteBase.SetupTest()
+	s.u = updater{
+		logger: s.loggerMock,
+		period: 100 * time.Millisecond,
+	}
+}
+
+func (s *UpdaterTestSuite) TestPeriodicUpdates() {
+	ticker := time.NewTicker(10 * time.Millisecond)
+	defer ticker.Stop()
+
+	lock := &sync.Mutex{}
+	collected := []time.Time{}
+
+	go s.u.run(s.ctx, func() error {
+		select {
+		case <-s.ctx.Done():
+		case value := <-ticker.C:
+			lock.Lock()
+			collected = append(collected, value)
+			lock.Unlock()
+		}
+
+		return nil
+	})
+
+	s.Eventually(func() bool {
+		lock.Lock()
+		defer lock.Unlock()
+
+		return len(collected) == 3
+	}, time.Second, 10*time.Millisecond)
+}
+
+func TestUpdater(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &UpdaterTestSuite{})
+}

mtglib/internal/dc/view.go

@@ -0,0 +1,23 @@
+package dc
+
+type dcView struct {
+	publicConfigs dcAddrSet
+}
+
+func (d dcView) getV4(dc int) []Addr {
+	var addrs []Addr
+
+	addrs = append(addrs, defaultDCAddrSet.getV4(dc)...)
+	addrs = append(addrs, d.publicConfigs.getV4(dc)...)
+
+	return addrs
+}
+
+func (d dcView) getV6(dc int) []Addr {
+	var addrs []Addr
+
+	addrs = append(addrs, defaultDCAddrSet.getV6(dc)...)
+	addrs = append(addrs, d.publicConfigs.getV6(dc)...)
+
+	return addrs
+}

mtglib/internal/dc/view_test.go

@@ -0,0 +1,81 @@
+package dc
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+)
+
+type ViewTestSuite struct {
+	suite.Suite
+
+	view dcView
+}
+
+func (suite *ViewTestSuite) SetupSuite() {
+	suite.view = dcView{
+		publicConfigs: dcAddrSet{
+			v4: map[int][]Addr{
+				111: {
+					{Network: "tcp4", Address: "127.0.0.1:443"},
+				},
+				203: {
+					{Network: "tcp4", Address: "127.0.0.2:443"},
+				},
+			},
+			v6: map[int][]Addr{
+				203: {
+					{Network: "tcp6", Address: "xxx"},
+				},
+			},
+		},
+	}
+}
+
+func (suite *ViewTestSuite) TestGetV4() {
+	testData := map[int][]Addr{
+		111: {
+			{Network: "tcp4", Address: "127.0.0.1:443"},
+		},
+		203: {
+			{Network: "tcp4", Address: "127.0.0.2:443"},
+			{Network: "tcp4", Address: "91.105.192.100:443"},
+		},
+		2: {
+			{Network: "tcp4", Address: "149.154.167.51:443"},
+			{Network: "tcp4", Address: "95.161.76.100:443"},
+		},
+	}
+
+	for dc, addresses := range testData {
+		suite.T().Run(fmt.Sprintf("dc%d", dc), func(t *testing.T) {
+			assert.ElementsMatch(t, addresses, suite.view.getV4(dc))
+		})
+	}
+}
+
+func (suite *ViewTestSuite) TestGetV6() {
+	testData := map[int][]Addr{
+		111: {},
+		203: {
+			{Network: "tcp6", Address: "xxx"},
+			{Network: "tcp6", Address: "[2a0a:f280:0203:000a:5000:0000:0000:0100]:443"},
+		},
+		1: {
+			{Network: "tcp6", Address: "[2001:b28:f23d:f001::a]:443"},
+		},
+	}
+
+	for dc, addresses := range testData {
+		suite.T().Run(fmt.Sprintf("dc%d", dc), func(t *testing.T) {
+			assert.ElementsMatch(t, addresses, suite.view.getV6(dc))
+		})
+	}
+}
+
+func TestView(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &ViewTestSuite{})
+}

mtglib/internal/doppel/conn.go

@@ -0,0 +1,118 @@
+package doppel
+
+import (
+	"bytes"
+	"context"
+	"sync"
+	"time"
+
+	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+)
+
+var doppelBufPool = sync.Pool{
+	New: func() any {
+		b := make([]byte, tls.MaxRecordSize)
+		return &b
+	},
+}
+
+type Conn struct {
+	essentials.Conn
+
+	p *connPayload
+}
+
+type connPayload struct {
+	ctx         context.Context
+	ctxCancel   context.CancelCauseFunc
+	stats       Stats
+	wg          sync.WaitGroup
+	writeStream bytes.Buffer
+	writtenCond sync.Cond
+	done        bool
+}
+
+func (c Conn) Write(p []byte) (int, error) {
+	if len(p) == 0 {
+		return 0, context.Cause(c.p.ctx)
+	}
+
+	c.p.writtenCond.L.Lock()
+	c.p.writeStream.Write(p)
+	c.p.writtenCond.L.Unlock()
+
+	c.p.writtenCond.Signal()
+
+	return len(p), context.Cause(c.p.ctx)
+}
+
+func (c Conn) start() {
+	bp := doppelBufPool.Get().(*[]byte)
+	buf := *bp
+	defer doppelBufPool.Put(bp)
+
+	timer := time.NewTimer(c.p.stats.Delay())
+	defer timer.Stop()
+
+	for {
+		select {
+		case <-c.p.ctx.Done():
+			return
+		case <-timer.C:
+			timer.Reset(c.p.stats.Delay())
+		}
+
+		size := c.p.stats.Size()
+
+		c.p.writtenCond.L.Lock()
+		for c.p.writeStream.Len() == 0 && !c.p.done {
+			c.p.writtenCond.Wait()
+		}
+		n, _ := c.p.writeStream.Read(buf[tls.SizeHeader : tls.SizeHeader+size])
+		c.p.writtenCond.L.Unlock()
+
+		if n == 0 {
+			continue
+		}
+
+		if err := tls.WriteRecordInPlace(c.Conn, buf, n); err != nil {
+			c.p.ctxCancel(err)
+			return
+		}
+	}
+}
+
+func (c Conn) Stop() {
+	c.p.ctxCancel(nil)
+
+	c.p.writtenCond.L.Lock()
+	c.p.done = true
+	c.p.writtenCond.L.Unlock()
+	c.p.writtenCond.Broadcast()
+
+	c.p.wg.Wait()
+}
+
+func NewConn(ctx context.Context, conn essentials.Conn, stats Stats) Conn {
+	ctx, cancel := context.WithCancelCause(ctx)
+	rv := Conn{
+		Conn: conn,
+		p: &connPayload{
+			ctx:       ctx,
+			ctxCancel: cancel,
+			stats:     stats,
+			writtenCond: sync.Cond{
+				L: &sync.Mutex{},
+			},
+		},
+	}
+
+	rv.p.writeStream.Grow(tls.DefaultBufferSize)
+
+	rv.p.wg.Go(func() {
+		rv.start()
+	})
+
+	return rv
+}

mtglib/internal/doppel/conn_test.go

@@ -0,0 +1,194 @@
+package doppel
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"errors"
+	"io"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/9seconds/mtg/v2/internal/testlib"
+	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+)
+
+type ConnMock struct {
+	testlib.EssentialsConnMock
+
+	mu          sync.Mutex
+	writeBuffer bytes.Buffer
+}
+
+func (m *ConnMock) Write(p []byte) (int, error) {
+	args := m.Called(p)
+	if err := args.Error(1); err != nil {
+		return args.Int(0), err
+	}
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	return m.writeBuffer.Write(p)
+}
+
+func (m *ConnMock) Written() []byte {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	return bytes.Clone(m.writeBuffer.Bytes())
+}
+
+type ConnTestSuite struct {
+	suite.Suite
+
+	connMock  *ConnMock
+	ctx       context.Context
+	ctxCancel context.CancelFunc
+}
+
+func (suite *ConnTestSuite) SetupTest() {
+	ctx, cancel := context.WithCancel(context.Background())
+	suite.ctx = ctx
+	suite.ctxCancel = cancel
+	suite.connMock = &ConnMock{}
+}
+
+func (suite *ConnTestSuite) TearDownTest() {
+	suite.ctxCancel()
+	suite.connMock.AssertExpectations(suite.T())
+}
+
+func (suite *ConnTestSuite) makeConn() Conn {
+	return NewConn(suite.ctx, suite.connMock, Stats{
+		k:      2.0,
+		lambda: 0.01,
+	})
+}
+
+func (suite *ConnTestSuite) TestWriteBuffersData() {
+	suite.connMock.
+		On("Write", mock.AnythingOfType("[]uint8")).
+		Return(0, nil).
+		Maybe()
+
+	c := suite.makeConn()
+	defer c.Stop()
+
+	n, err := c.Write([]byte{1, 2, 3})
+	suite.NoError(err)
+	suite.Equal(3, n)
+}
+
+func (suite *ConnTestSuite) TestWriteOutputsTLSRecords() {
+	suite.connMock.
+		On("Write", mock.AnythingOfType("[]uint8")).
+		Return(0, nil).
+		Maybe()
+
+	c := suite.makeConn()
+
+	payload := []byte("hello doppelganger")
+	_, err := c.Write(payload)
+	suite.NoError(err)
+
+	suite.Eventually(func() bool {
+		return len(suite.connMock.Written()) > 0
+	}, 2*time.Second, time.Millisecond)
+
+	c.Stop()
+
+	assembled := &bytes.Buffer{}
+	reader := bytes.NewReader(suite.connMock.Written())
+
+	for {
+		header := make([]byte, tls.SizeHeader)
+		if _, err := io.ReadFull(reader, header); err != nil {
+			break
+		}
+
+		suite.Equal(byte(tls.TypeApplicationData), header[0])
+		suite.Equal(tls.TLSVersion[:], header[tls.SizeRecordType:tls.SizeRecordType+tls.SizeVersion])
+
+		length := binary.BigEndian.Uint16(header[tls.SizeRecordType+tls.SizeVersion:])
+		suite.Greater(length, uint16(0))
+
+		rec := make([]byte, length)
+		_, err := io.ReadFull(reader, rec)
+		suite.NoError(err)
+
+		assembled.Write(rec)
+	}
+
+	suite.Equal(payload, assembled.Bytes())
+}
+
+func (suite *ConnTestSuite) TestWriteReturnsErrorAfterStop() {
+	suite.connMock.
+		On("Write", mock.AnythingOfType("[]uint8")).
+		Return(0, nil).
+		Maybe()
+
+	c := suite.makeConn()
+	c.Stop()
+
+	time.Sleep(10 * time.Millisecond)
+
+	_, err := c.Write([]byte{1})
+	suite.Error(err)
+}
+
+func (suite *ConnTestSuite) TestStopDoesNotDeadlockWhenStartIsWaiting() {
+	suite.connMock.
+		On("Write", mock.AnythingOfType("[]uint8")).
+		Return(0, nil).
+		Maybe()
+
+	for range 100 {
+		func() {
+			ctx, cancel := context.WithCancel(suite.ctx)
+			defer cancel()
+
+			c := NewConn(ctx, suite.connMock, Stats{
+				k:      2.0,
+				lambda: 0.01,
+			})
+
+			done := make(chan struct{})
+			go func() {
+				defer close(done)
+				c.Stop()
+			}()
+
+			select {
+			case <-done:
+			case <-time.After(2 * time.Second):
+				suite.Fail("Stop() deadlocked: start() likely stuck in writtenCond.Wait()")
+			}
+		}()
+	}
+}
+
+func (suite *ConnTestSuite) TestStopOnUnderlyingWriteError() {
+	suite.connMock.
+		On("Write", mock.AnythingOfType("[]uint8")).
+		Return(0, errors.New("connection reset")).
+		Maybe()
+
+	c := suite.makeConn()
+
+	_, _ = c.Write([]byte("data"))
+
+	suite.Eventually(func() bool {
+		_, err := c.Write([]byte{1})
+		return err != nil
+	}, 2*time.Second, time.Millisecond)
+}
+
+func TestConn(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &ConnTestSuite{})
+}

mtglib/internal/doppel/ganger.go

@@ -0,0 +1,267 @@
+package doppel
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/9seconds/mtg/v2/essentials"
+)
+
+const (
+	DoppelGangerMaxDurations  = 4096
+	DoppelGangerScoutRaidEach = 6 * time.Hour
+	DoppelGangerScoutRepeats  = 10
+
+	MinCertSizesToCalculate = 3
+)
+
+// NoiseParams holds the measured cert chain size for FakeTLS noise calibration.
+// If Mean is 0, the caller should use a legacy fallback.
+type NoiseParams struct {
+	Mean   int
+	Jitter int
+}
+
+type scoutRaidResult struct {
+	durations []time.Duration
+	certSizes []int
+}
+
+type gangerConnRequest struct {
+	ret     chan<- Conn
+	payload essentials.Conn
+}
+
+type Ganger struct {
+	ctx       context.Context
+	ctxCancel context.CancelFunc
+	logger    Logger
+	wg        sync.WaitGroup
+
+	scout            Scout
+	scoutRaidEach    time.Duration
+	scoutRaidRepeats int
+
+	drs bool
+
+	stats     Stats
+	durations []time.Duration
+	certSizes []int
+
+	noiseParams atomic.Pointer[NoiseParams]
+
+	connRequests chan gangerConnRequest
+}
+
+func (g *Ganger) Shutdown() {
+	g.ctxCancel()
+	g.wg.Wait()
+}
+
+func (g *Ganger) Run() {
+	g.wg.Go(func() {
+		g.run()
+	})
+}
+
+// NoiseParams returns the current cert-size-based noise parameters.
+// Returns zero-value NoiseParams if not yet measured (caller should use fallback).
+func (g *Ganger) NoiseParams() NoiseParams {
+	if p := g.noiseParams.Load(); p != nil {
+		return *p
+	}
+
+	return NoiseParams{}
+}
+
+func (g *Ganger) NewConn(conn essentials.Conn) (Conn, error) {
+	rvChan := make(chan Conn)
+	req := gangerConnRequest{
+		ret:     rvChan,
+		payload: conn,
+	}
+	defer close(req.ret)
+
+	select {
+	case <-g.ctx.Done():
+		return Conn{}, context.Cause(g.ctx)
+	case g.connRequests <- req:
+	}
+
+	select {
+	case <-g.ctx.Done():
+		return Conn{}, context.Cause(g.ctx)
+	case conn := <-rvChan:
+		return conn, nil
+	}
+}
+
+func (g *Ganger) run() {
+	scoutTicker := time.NewTicker(g.scoutRaidEach)
+	defer func() {
+		scoutTicker.Stop()
+
+		select {
+		case <-scoutTicker.C:
+		default:
+		}
+	}()
+
+	scoutCollectedChan := make(chan scoutRaidResult)
+	currentScoutCollectedChan := scoutCollectedChan
+
+	updatedStatsChan := make(chan Stats)
+
+	g.wg.Go(func() {
+		g.runScoutRaid(scoutCollectedChan)
+	})
+
+	for {
+		select {
+		case <-g.ctx.Done():
+			return
+		case result := <-currentScoutCollectedChan:
+			g.durations = append(g.durations, result.durations...)
+
+			if len(g.durations) > DoppelGangerMaxDurations {
+				copy(g.durations, g.durations[len(g.durations)-DoppelGangerMaxDurations:])
+				g.durations = g.durations[:DoppelGangerMaxDurations]
+			}
+
+			// Update cert sizes and recompute noise params.
+			g.certSizes = append(g.certSizes, result.certSizes...)
+			if len(g.certSizes) > DoppelGangerMaxDurations {
+				g.certSizes = g.certSizes[len(g.certSizes)-DoppelGangerMaxDurations:]
+			}
+
+			if len(g.certSizes) >= MinCertSizesToCalculate {
+				g.updateNoiseParams()
+			}
+
+			if len(g.durations) < MinDurationsToCalculate {
+				continue
+			}
+
+			durations := g.durations
+			currentScoutCollectedChan = nil
+			g.wg.Go(func() {
+				select {
+				case <-g.ctx.Done():
+				case updatedStatsChan <- NewStats(durations, g.drs):
+				}
+			})
+		case stats := <-updatedStatsChan:
+			g.stats = stats
+			currentScoutCollectedChan = scoutCollectedChan
+		case <-scoutTicker.C:
+			g.wg.Go(func() {
+				g.runScoutRaid(scoutCollectedChan)
+			})
+		case req := <-g.connRequests:
+			select {
+			case <-g.ctx.Done():
+			case req.ret <- NewConn(g.ctx, req.payload, g.stats):
+			}
+		}
+	}
+}
+
+func (g *Ganger) updateNoiseParams() {
+	if len(g.certSizes) == 0 {
+		return
+	}
+
+	sum := 0
+	for _, s := range g.certSizes {
+		sum += s
+	}
+
+	mean := sum / len(g.certSizes)
+
+	maxDev := 0
+	for _, s := range g.certSizes {
+		d := s - mean
+		if d < 0 {
+			d = -d
+		}
+
+		if d > maxDev {
+			maxDev = d
+		}
+	}
+
+	if maxDev < 100 {
+		maxDev = 100
+	}
+
+	np := &NoiseParams{Mean: mean, Jitter: maxDev}
+	g.noiseParams.Store(np)
+
+	g.logger.Info(fmt.Sprintf(
+		"updated noise params: mean=%d jitter=%d samples=%d",
+		mean, maxDev, len(g.certSizes),
+	))
+}
+
+func (g *Ganger) runScoutRaid(rvChan chan<- scoutRaidResult) {
+	var result scoutRaidResult
+
+	for range g.scoutRaidRepeats {
+		learned, err := g.scout.Learn(g.ctx)
+		if err != nil {
+			g.logger.WarningError("cannot learn", err)
+			continue
+		}
+
+		result.durations = append(result.durations, learned.Durations...)
+
+		if learned.CertSize > 0 {
+			result.certSizes = append(result.certSizes, learned.CertSize)
+		}
+	}
+
+	select {
+	case <-g.ctx.Done():
+		return
+	case rvChan <- result:
+	}
+}
+
+func NewGanger(
+	ctx context.Context,
+	network Network,
+	logger Logger,
+	scoutEach time.Duration,
+	scoutRepeats int,
+	urls []string,
+	drs bool,
+) *Ganger {
+	ctx, cancel := context.WithCancel(ctx)
+
+	if scoutEach == 0 {
+		scoutEach = DoppelGangerScoutRaidEach
+	}
+
+	if scoutRepeats == 0 {
+		scoutRepeats = DoppelGangerScoutRepeats
+	}
+
+	return &Ganger{
+		ctx:              ctx,
+		ctxCancel:        cancel,
+		logger:           logger,
+		scoutRaidEach:    scoutEach,
+		scoutRaidRepeats: scoutRepeats,
+		drs:              drs,
+		stats: Stats{
+			k:      StatsDefaultK,
+			lambda: StatsDefaultLambda,
+			drs:    drs,
+		},
+		scout:        NewScout(network, urls),
+		connRequests: make(chan gangerConnRequest),
+	}
+}

mtglib/internal/doppel/ganger_test.go

@@ -0,0 +1,107 @@
+package doppel
+
+import (
+	"bytes"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/9seconds/mtg/v2/internal/testlib"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+)
+
+type GangerTestSuite struct {
+	TLSServerTestSuite
+
+	log *LoggerMock
+	g   *Ganger
+}
+
+func (suite *GangerTestSuite) SetupTest() {
+	suite.TLSServerTestSuite.SetupTest()
+
+	suite.log = &LoggerMock{}
+	suite.log.
+		On("Info", mock.AnythingOfType("string")).
+		Maybe()
+	suite.log.
+		On("WarningError", mock.AnythingOfType("string"), mock.Anything).
+		Maybe()
+
+	suite.g = NewGanger(suite.ctx, suite.network, suite.log, time.Hour, 1, suite.urls, true)
+	suite.g.Run()
+}
+
+func (suite *GangerTestSuite) TearDownTest() {
+	suite.g.Shutdown()
+
+	suite.log.AssertExpectations(suite.T())
+	suite.TLSServerTestSuite.TearDownTest()
+}
+
+func (suite *GangerTestSuite) TestNewConnAfterShutdown() {
+	suite.g.Shutdown()
+	connMock := &testlib.EssentialsConnMock{}
+
+	_, err := suite.g.NewConn(connMock)
+	suite.Error(err)
+}
+
+func (suite *GangerTestSuite) TestNewConnWhileRunning() {
+	connMock := &testlib.EssentialsConnMock{}
+	connMock.
+		On("Write", mock.AnythingOfType("[]uint8")).
+		Return(0, nil).
+		Maybe()
+	connMock.On("Close").
+		Return(nil).
+		Maybe()
+
+	conn, err := suite.g.NewConn(connMock)
+	suite.NoError(err)
+
+	conn.Stop()
+}
+
+func (suite *GangerTestSuite) TestNewConnWriteProducesTLSRecords() {
+	var (
+		mu  sync.Mutex
+		buf bytes.Buffer
+	)
+
+	connMock := &testlib.EssentialsConnMock{}
+	connMock.On("Write", mock.AnythingOfType("[]uint8")).
+		Run(func(args mock.Arguments) {
+			mu.Lock()
+			buf.Write(args.Get(0).([]byte))
+			mu.Unlock()
+		}).
+		Return(0, nil).
+		Maybe()
+	connMock.On("Close").
+		Return(nil).
+		Maybe()
+
+	conn, err := suite.g.NewConn(connMock)
+	suite.NoError(err)
+
+	payload := bytes.Repeat([]byte("x"), 512)
+	_, err = conn.Write(payload)
+	suite.NoError(err)
+
+	time.Sleep(500 * time.Millisecond)
+	conn.Stop()
+
+	mu.Lock()
+	written := buf.Bytes()
+	mu.Unlock()
+
+	suite.NotEmpty(written)
+}
+
+func TestGanger(t *testing.T) {
+	t.Parallel()
+
+	suite.Run(t, &GangerTestSuite{})
+}

mtglib/internal/doppel/init.go

@@ -0,0 +1,43 @@
+package doppel
+
+import (
+	"context"
+	"net"
+	"net/http"
+	"time"
+
+	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+)
+
+const (
+	// Please see Stats description
+	// https://blog.cloudflare.com/optimizing-tls-over-tcp-to-reduce-latency/
+	// https://github.com/cloudflare/sslconfig/blob/master/patches/nginx__dynamic_tls_records.patch
+	TLSRecordSizeStart = 1450
+	TLSRecordSizeAccel = 4096
+	TLSRecordSizeMax   = 16384 - tls.SizeHeader
+
+	TLSCounterAccelAfter = 40
+	TLSCounterMaxAfter   = TLSCounterAccelAfter + 20
+
+	TLSRecordSizeResetAfter = time.Second
+)
+
+// copypasted from mtglib
+type Network interface {
+	// Dial establishes context-free TCP connections.
+	Dial(network, address string) (essentials.Conn, error)
+
+	// DialContext dials using a context. This is a preferable way of
+	// establishing TCP connections.
+	DialContext(ctx context.Context, network, address string) (essentials.Conn, error)
+
+	// MakeHTTPClient build an HTTP client with given dial function. If nothing is
+	// provided, then DialContext of this interface is going to be used.
+	MakeHTTPClient(func(ctx context.Context, network, address string) (essentials.Conn, error)) *http.Client
+
+	// NativeDialer returns a configured instance of native dialer that
+	// skips proxy connections or any other irrelevant settings.
+	NativeDialer() *net.Dialer
+}

mtglib/internal/doppel/init_test.go

@@ -0,0 +1,107 @@
+package doppel
+
+import (
+	"context"
+	"crypto/tls"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"time"
+
+	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+)
+
+type SimpleNetwork struct{}
+
+func (s SimpleNetwork) Dial(network, address string) (essentials.Conn, error) {
+	return s.DialContext(context.Background(), network, address)
+}
+
+func (s SimpleNetwork) DialContext(ctx context.Context, network, address string) (essentials.Conn, error) {
+	d := &net.Dialer{}
+
+	conn, err := d.DialContext(ctx, network, address)
+	if err != nil {
+		return nil, err
+	}
+
+	return conn.(*net.TCPConn), nil
+}
+
+func (s SimpleNetwork) NativeDialer() *net.Dialer {
+	return &net.Dialer{}
+}
+
+func (s SimpleNetwork) MakeHTTPClient(dialFunc func(ctx context.Context, network, address string) (essentials.Conn, error)) *http.Client {
+	if dialFunc == nil {
+		dialFunc = s.DialContext
+	}
+
+	return &http.Client{
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{
+				InsecureSkipVerify: true, //nolint: gosec
+			},
+			DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
+				return dialFunc(ctx, network, address)
+			},
+		},
+	}
+}
+
+type TLSServerTestSuite struct {
+	suite.Suite
+
+	tlsServer *httptest.Server
+	ctx       context.Context
+	ctxCancel context.CancelFunc
+	network   SimpleNetwork
+	urls      []string
+}
+
+func (suite *TLSServerTestSuite) SetupSuite() {
+	suite.tlsServer = httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		w.Header().Add("Hello", "how long")
+
+		if _, err := w.Write([]byte{1, 2, 3}); err != nil {
+			panic(err)
+		}
+
+		time.Sleep(5 * time.Millisecond)
+
+		if _, err := w.Write([]byte{1, 2, 3}); err != nil {
+			panic(err)
+		}
+	}))
+	suite.urls = []string{suite.tlsServer.URL}
+}
+
+func (suite *TLSServerTestSuite) SetupTest() {
+	ctx, cancel := context.WithCancel(context.Background())
+	suite.ctx = ctx
+	suite.ctxCancel = cancel
+}
+
+func (suite *TLSServerTestSuite) TearDownTest() {
+	suite.ctxCancel()
+	suite.tlsServer.CloseClientConnections()
+}
+
+func (suite *TLSServerTestSuite) TearDownSuite() {
+	suite.tlsServer.Close()
+}
+
+type LoggerMock struct {
+	mock.Mock
+}
+
+func (l *LoggerMock) Info(msg string) {
+	l.Called(msg)
+}
+
+func (l *LoggerMock) WarningError(msg string, err error) {
+	l.Called(msg, err)
+}

mtglib/internal/doppel/logger.go

@@ -0,0 +1,6 @@
+package doppel
+
+type Logger interface {
+	Info(msg string)
+	WarningError(msg string, err error)
+}

mtglib/internal/doppel/scout.go

@@ -0,0 +1,146 @@
+package doppel
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+)
+
+// ScoutResult holds measurements from a single scout HTTP request.
+type ScoutResult struct {
+	Durations []time.Duration
+	CertSize  int // total ApplicationData bytes during TLS handshake; 0 if unknown
+}
+
+type Scout struct {
+	network Network
+	urls    []string
+}
+
+func (s Scout) Learn(ctx context.Context) (ScoutResult, error) {
+	var combined ScoutResult
+
+	for _, url := range s.urls {
+		learned, err := s.learn(ctx, url)
+		if err != nil {
+			return ScoutResult{}, err
+		}
+
+		combined.Durations = append(combined.Durations, learned.Durations...)
+
+		if learned.CertSize > 0 && combined.CertSize == 0 {
+			combined.CertSize = learned.CertSize
+		}
+	}
+
+	return combined, nil
+}
+
+func (s Scout) learn(ctx context.Context, url string) (ScoutResult, error) {
+	client, results := s.makeClient()
+
+	if !strings.HasPrefix(url, "https://") {
+		return ScoutResult{}, fmt.Errorf("url %s must be https", url)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return ScoutResult{}, err
+	}
+
+	resp, err := client.Do(req)
+	if resp != nil {
+		io.Copy(io.Discard, resp.Body) //nolint: errcheck
+		resp.Body.Close()              //nolint: errcheck
+		client.CloseIdleConnections()
+	}
+
+	if err != nil {
+		return ScoutResult{}, err
+	}
+
+	data, writeIndex := results.Snapshot()
+
+	if len(data) == 0 {
+		return ScoutResult{}, nil
+	}
+
+	var result ScoutResult
+
+	// Compute inter-record durations (existing logic).
+	lastTimestamp := time.Time{}
+
+	for i, v := range data {
+		if v.recordType != tls.TypeApplicationData {
+			continue
+		}
+
+		if lastTimestamp.IsZero() {
+			if i > 0 {
+				lastTimestamp = data[i-1].timestamp
+			} else {
+				lastTimestamp = v.timestamp
+			}
+		}
+
+		result.Durations = append(result.Durations, v.timestamp.Sub(lastTimestamp))
+		lastTimestamp = v.timestamp
+	}
+
+	// Compute cert size: sum of ApplicationData payload between CCS and
+	// the first client Write (which marks the end of server handshake).
+	seenCCS := false
+	boundary := writeIndex
+	if boundary < 0 {
+		boundary = len(data)
+	}
+
+	for i, v := range data {
+		if i >= boundary {
+			break
+		}
+
+		if v.recordType == tls.TypeChangeCipherSpec {
+			seenCCS = true
+			continue
+		}
+
+		if seenCCS && v.recordType == tls.TypeApplicationData {
+			result.CertSize += v.payloadLen
+		}
+	}
+
+	return result, nil
+}
+
+func (s Scout) makeClient() (*http.Client, *ScoutConnCollected) {
+	dialer := s.network.NativeDialer()
+	collected := NewScoutConnCollected()
+	client := s.network.MakeHTTPClient(func(
+		ctx context.Context,
+		network string,
+		address string,
+	) (essentials.Conn, error) {
+		conn, err := dialer.DialContext(ctx, network, address)
+		if err != nil {
+			return nil, err
+		}
+
+		return NewScoutConn(essentials.WrapNetConn(conn), collected), nil
+	})
+
+	return client, collected
+}
+
+func NewScout(network Network, urls []string) Scout {
+	return Scout{
+		network: network,
+		urls:    urls,
+	}
+}

mtglib/internal/doppel/scout_conn.go

@@ -0,0 +1,70 @@
+package doppel
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+
+	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+)
+
+type ScoutConn struct {
+	tls.Conn
+
+	results *ScoutConnCollected
+	rawBuf  *bytes.Buffer
+	seenCCS bool
+}
+
+func (s *ScoutConn) Read(p []byte) (int, error) {
+	buf := &bytes.Buffer{}
+
+	for {
+		if n, err := s.rawBuf.Read(p); err == nil {
+			return n, nil
+		}
+
+		s.rawBuf.Reset()
+
+		recordType, length, err := tls.ReadRecord(s.Conn, buf)
+		if err != nil {
+			return 0, err
+		}
+
+		if recordType == tls.TypeChangeCipherSpec {
+			s.seenCCS = true
+		}
+
+		s.results.Add(recordType, int(length))
+		s.rawBuf.Write([]byte{recordType})
+		s.rawBuf.Write(tls.TLSVersion[:])
+
+		if err := binary.Write(s.rawBuf, binary.BigEndian, uint16(length)); err != nil {
+			return 0, err
+		}
+
+		if _, err := io.Copy(s.rawBuf, buf); err != nil {
+			return 0, err
+		}
+	}
+}
+
+func (s *ScoutConn) Write(p []byte) (int, error) {
+	if s.seenCCS {
+		s.results.MarkWrite()
+	}
+
+	return s.Conn.Write(p)
+}
+
+func NewScoutConn(conn essentials.Conn, results *ScoutConnCollected) *ScoutConn {
+	rawBuf := &bytes.Buffer{}
+	rawBuf.Grow(tls.MaxRecordSize)
+
+	return &ScoutConn{
+		Conn:    tls.New(conn, false, false),
+		results: results,
+		rawBuf:  rawBuf,
+	}
+}

mtglib/internal/doppel/scout_conn_collected.go

@@ -0,0 +1,59 @@
+package doppel
+
+import (
+	"slices"
+	"sync"
+	"time"
+)
+
+const (
+	ScoutConnCollectedPreallocSize = 100
+)
+
+type ScoutConnResult struct {
+	timestamp  time.Time
+	recordType byte
+	payloadLen int
+}
+
+type ScoutConnCollected struct {
+	mu         sync.Mutex
+	data       []ScoutConnResult
+	writeIndex int // index at which client first wrote post-handshake data; -1 if not set
+}
+
+func (s *ScoutConnCollected) Add(record byte, payloadLen int) {
+	s.mu.Lock()
+	s.data = append(s.data, ScoutConnResult{
+		timestamp:  time.Now(),
+		recordType: record,
+		payloadLen: payloadLen,
+	})
+	s.mu.Unlock()
+}
+
+// MarkWrite records the current data length as the handshake boundary.
+func (s *ScoutConnCollected) MarkWrite() {
+	s.mu.Lock()
+	if s.writeIndex < 0 {
+		s.writeIndex = len(s.data)
+	}
+	s.mu.Unlock()
+}
+
+// Snapshot returns a copy of the collected data and the write index.
+func (s *ScoutConnCollected) Snapshot() ([]ScoutConnResult, int) {
+	s.mu.Lock()
+	snapshot := slices.Clone(s.data)
+	writeIndex := s.writeIndex
+	s.mu.Unlock()
+
+	return snapshot, writeIndex
+}
+
+func NewScoutConnCollected() *ScoutConnCollected {
+	return &ScoutConnCollected{
+		data:       make([]ScoutConnResult, 0, ScoutConnCollectedPreallocSize),
+		writeIndex: -1,
+	}
+}

mtglib/internal/doppel/scout_conn_collected_test.go

@@ -0,0 +1,86 @@
+package doppel
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+	"github.com/stretchr/testify/suite"
+)
+
+type ScoutConnCollectedTestSuite struct {
+	suite.Suite
+}
+
+func (suite *ScoutConnCollectedTestSuite) TestAddSingle() {
+	collected := NewScoutConnCollected()
+	collected.Add(tls.TypeApplicationData, 100)
+
+	data, _ := collected.Snapshot()
+
+	suite.Len(data, 1)
+	suite.Equal(byte(tls.TypeApplicationData), data[0].recordType)
+}
+
+func (suite *ScoutConnCollectedTestSuite) TestAddTimestampsAreMonotonic() {
+	collected := NewScoutConnCollected()
+
+	collected.Add(tls.TypeApplicationData, 100)
+
+	time.Sleep(time.Microsecond)
+	collected.Add(tls.TypeApplicationData, 100)
+
+	time.Sleep(time.Microsecond)
+	collected.Add(tls.TypeApplicationData, 100)
+
+	data, _ := collected.Snapshot()
+
+	for i := 1; i < len(data); i++ {
+		suite.True(data[i].timestamp.After(data[i-1].timestamp))
+	}
+}
+
+func (suite *ScoutConnCollectedTestSuite) TestConcurrentAddSnapshot() {
+	collected := NewScoutConnCollected()
+
+	var wg sync.WaitGroup
+
+	wg.Add(3)
+
+	go func() {
+		defer wg.Done()
+
+		for i := 0; i < 1000; i++ {
+			collected.Add(tls.TypeApplicationData, i)
+		}
+	}()
+
+	go func() {
+		defer wg.Done()
+
+		for i := 0; i < 100; i++ {
+			collected.MarkWrite()
+		}
+	}()
+
+	go func() {
+		defer wg.Done()
+
+		for i := 0; i < 1000; i++ {
+			// call Snapshot concurrently to exercise the lock under -race
+			collected.Snapshot() //nolint:errcheck
+		}
+	}()
+
+	wg.Wait()
+
+	data, writeIndex := collected.Snapshot()
+	suite.Len(data, 1000)
+	suite.GreaterOrEqual(writeIndex, 0)
+}
+
+func TestScoutConnCollected(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &ScoutConnCollectedTestSuite{})
+}

mtglib/internal/doppel/scout_test.go

@@ -0,0 +1,39 @@
+package doppel
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+)
+
+type ScoutTestSuite struct {
+	TLSServerTestSuite
+
+	scout Scout
+}
+
+func (suite *ScoutTestSuite) SetupSuite() {
+	suite.TLSServerTestSuite.SetupSuite()
+
+	suite.scout = Scout{
+		network: suite.network,
+		urls:    suite.urls,
+	}
+}
+
+func (suite *ScoutTestSuite) TestCollectResults() {
+	result, err := suite.scout.Learn(suite.ctx)
+	suite.NoError(err)
+	suite.Less(3, len(result.Durations))
+}
+
+func (suite *ScoutTestSuite) TestCollectNothing() {
+	suite.ctxCancel()
+
+	_, err := suite.scout.Learn(suite.ctx)
+	suite.Error(err)
+}
+
+func TestScout(t *testing.T) {
+	suite.Run(t, &ScoutTestSuite{})
+}

mtglib/internal/doppel/stats.go

@@ -0,0 +1,170 @@
+package doppel
+
+import (
+	"math"
+	"math/rand/v2"
+	"time"
+)
+
+const (
+	StatsBisectTimes = 70
+	StatsLowK        = 0.01
+	StatsHighK       = 10.0
+
+	// do not calculate statistics if we have < than this number of durations
+	MinDurationsToCalculate = 100
+
+	// these values are taken from ok.ru. measured from moscow site.
+	StatsDefaultK      = 0.37846373895785335
+	StatsDefaultLambda = 1.73177086015485
+
+	// how many bytes should we drift
+	DRSNoise = 100
+)
+
+// Stats is responsible for generating values that are distributed according
+// to some statistical distribution.
+//
+// It follows several ideas:
+//  1. Based on nginx and Cloudflare behaviour, even if server is eager
+//     to send a lot, they all start with small TLS packets that are
+//     approximately MTU-sized. After
+//  2. After ~40 TLS records, server considers TCP session as somewhat solid
+//     and reliable and ramps up to 4096.
+//  3. After ~20 TLS records more it jumps to the max 16384 bytes and keep
+//     this size as long as it can
+//  4. If there is no any byte within a connection for a longer time period,
+//     this counter resets.
+//
+// This is called Dynamic TLS Record Sizing
+//   - https://blog.cloudflare.com/optimizing-tls-over-tcp-to-reduce-latency/
+//   - https://community.f5.com/kb/technicalarticles/boosting-tls-performance-with-dynamic-record-sizing-on-big-ip/280798
+//   - https://www.igvita.com/2013/10/24/optimizing-tls-record-size-and-buffering-latency/
+//
+// And this optimized for the very first byte, so web browsers could start to
+// render as early as possible, showing user some preliminary results, optimizing
+// for perceived latency.
+//
+// Since this is very typical for the website, we also aim for that.
+//
+// Another important idea is how delays between TLS packets are distributed.
+// In case of sending huge heavy content with max sized record, delays have
+// lognormal distribution. But a nature of a typical website shows that
+// it eagers to deliver as fast as it can in a few very first records and
+// could possibly slow down later.
+//
+// This is perfectly described by Weibull distribution:
+//   - https://en.wikipedia.org/wiki/Weibull_distribution
+//   - https://ieeexplore.ieee.org/document/6662948
+//   - https://www.researchgate.net/publication/224621285_Traffic_modelling_and_cost_optimization_for_transmitting_traffic_messages_over_a_hybrid_broadcast_and_cellular_network
+//   - https://ir.uitm.edu.my/id/eprint/105386/1/105386.pdf
+//
+// In other word, a combination of Dynamic TLS Record Sizing hints us for
+// Weibull distribution.
+//
+// But we also have to keep in mind that DRS is not well spread yet. In most cases
+// users still rely on OpenSSL or webserver defaults. OpenSSL chunks with
+// biggest packet sizes, nginx relies on static setting that is 16k by default.
+// Thus, dynamic sizing has to be present but we cannot oblige users to use that.
+type Stats struct {
+	sizeLastRequested time.Time
+	sizeCounter       int
+
+	// https://en.wikipedia.org/wiki/Shape_parameter
+	k float64
+	// https://en.wikipedia.org/wiki/Scale_parameter
+	lambda float64
+
+	// Dynamic Record Sizing
+	drs bool
+}
+
+func (d *Stats) Delay() time.Duration {
+	// u ∈ (0, 1], avoids ln(0)
+	u := 1.0 - rand.Float64()
+
+	// X = λ·(-ln U)^(1/k)
+	generated := d.lambda * math.Pow(-math.Log(u), 1.0/d.k)
+
+	// generated is in milliseconds
+	return time.Duration(generated * float64(time.Millisecond))
+}
+
+func (d *Stats) Size() int {
+	if time.Since(d.sizeLastRequested) > TLSRecordSizeResetAfter {
+		d.sizeCounter = 0
+	}
+
+	if !d.drs {
+		return TLSRecordSizeMax
+	}
+
+	d.sizeLastRequested = time.Now()
+	d.sizeCounter++
+
+	switch {
+	case d.sizeCounter <= TLSCounterAccelAfter:
+		return TLSRecordSizeStart - rand.IntN(DRSNoise)
+	case d.sizeCounter <= TLSCounterMaxAfter:
+		return TLSRecordSizeAccel - rand.IntN(DRSNoise)
+	}
+
+	return TLSRecordSizeMax
+}
+
+func NewStats(durations []time.Duration, drs bool) Stats {
+	n := float64(len(durations))
+
+	// in milliseconds
+	durFloats := make([]float64, len(durations))
+	for i, v := range durations {
+		durFloats[i] = float64(v.Microseconds()) / 1000.0
+	}
+
+	// The bisection solves the standard Weibull MLE equation for shape
+	// parameter k. There is no any good formula for doing that so we
+	// approximate it by several bisections. The number of operations
+	// is statically defined by a constant.
+
+	sumLog := 0.0
+	for _, v := range durFloats {
+		sumLog += math.Log(v)
+	}
+
+	lowK := StatsLowK
+	highK := StatsHighK
+
+	for range StatsBisectTimes {
+		midK := (lowK + highK) / 2.0
+		sumXK := 0.0
+		sumXKLog := 0.0
+
+		for _, v := range durFloats {
+			xk := math.Pow(v, midK)
+			sumXK += xk
+			sumXKLog += xk * math.Log(v)
+		}
+
+		if (1.0/midK)+(sumLog/n)-(sumXKLog/sumXK) > 0 {
+			lowK = midK
+		} else {
+			highK = midK
+		}
+	}
+
+	k := (lowK + highK) / 2
+
+	sumXK := 0.0
+	for _, v := range durFloats {
+		sumXK += math.Pow(v, k)
+	}
+
+	// λ = (Σxᵢᵏ / n)^(1/k)
+	lambda := math.Pow(sumXK/n, 1.0/k)
+
+	return Stats{
+		k:      k,
+		lambda: lambda,
+		drs:    drs,
+	}
+}

mtglib/internal/doppel/stats_test.go

@@ -0,0 +1,219 @@
+package doppel
+
+import (
+	"math"
+	"math/rand/v2"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/suite"
+)
+
+type StatsTestSuite struct {
+	suite.Suite
+}
+
+func (suite *StatsTestSuite) GenWeibull(k, lambda float64, n int, seed uint64) []time.Duration {
+	rng := rand.New(rand.NewPCG(seed, 0))
+	samples := make([]time.Duration, n)
+
+	for i := range samples {
+		u := 1.0 - rng.Float64()
+		ms := lambda * math.Pow(-math.Log(u), 1.0/k)
+		d := time.Duration(ms * float64(time.Millisecond))
+
+		if d < time.Microsecond {
+			time.Sleep(time.Microsecond)
+			d = time.Microsecond
+		}
+
+		samples[i] = d
+	}
+
+	return samples
+}
+
+func (suite *StatsTestSuite) TestNewStatsRecoverParameters() {
+	knownK := 1.5
+	knownLambda := 100.0
+
+	samples := suite.GenWeibull(knownK, knownLambda, 5000, 42)
+	stats := NewStats(samples, true)
+
+	suite.InDelta(knownK, stats.k, 0.1)
+	suite.InDelta(knownLambda, stats.lambda, 5.0)
+}
+
+func (suite *StatsTestSuite) TestNewStatsExponentialCase() {
+	// When k=1, Weibull reduces to exponential distribution.
+	knownK := 1.0
+	knownLambda := 50.0
+
+	samples := suite.GenWeibull(knownK, knownLambda, 5000, 123)
+	stats := NewStats(samples, true)
+
+	suite.InDelta(knownK, stats.k, 0.1)
+	suite.InDelta(knownLambda, stats.lambda, 5.0)
+}
+
+func (suite *StatsTestSuite) TestNewStatsSmallK() {
+	// k < 1 produces a heavy-tailed distribution typical for network delays.
+	// Lambda must be large enough so samples stay above microsecond precision
+	// after time.Duration round-trip.
+	knownK := 0.6
+	knownLambda := 100.0
+
+	samples := suite.GenWeibull(knownK, knownLambda, 10000, 99)
+	stats := NewStats(samples, true)
+
+	suite.InDelta(knownK, stats.k, 0.05)
+	suite.InDelta(knownLambda, stats.lambda, 5.0)
+}
+
+func (suite *StatsTestSuite) TestNewStatsLargeK() {
+	// k > 1: light tail, concentrated around the mode.
+	knownK := 5.0
+	knownLambda := 200.0
+
+	samples := suite.GenWeibull(knownK, knownLambda, 5000, 77)
+	stats := NewStats(samples, true)
+
+	suite.InDelta(knownK, stats.k, 0.3)
+	suite.InDelta(knownLambda, stats.lambda, 5.0)
+}
+
+func (suite *StatsTestSuite) TestDelayNonNegative() {
+	stats := &Stats{
+		k:      1.5,
+		lambda: 100.0,
+	}
+
+	for range 200 {
+		dur := stats.Delay()
+		suite.GreaterOrEqual(dur, time.Duration(0))
+	}
+}
+
+func (suite *StatsTestSuite) TestDelayDistributionMean() {
+	// Weibull mean = λ · Γ(1 + 1/k)
+	k := 2.0
+	lambda := 50.0
+	stats := &Stats{k: k, lambda: lambda}
+
+	n := 50000
+	sum := 0.0
+
+	for range n {
+		dur := stats.Delay()
+		sum += float64(dur) / float64(time.Millisecond)
+	}
+
+	sampleMean := sum / float64(n)
+	expectedMean := lambda * math.Gamma(1.0+1.0/k)
+
+	suite.InDelta(expectedMean, sampleMean, expectedMean*0.05)
+}
+
+func (suite *StatsTestSuite) TestNewStatsRoundTrip() {
+	// Estimate parameters from data, then verify that Delay samples
+	// from the fitted distribution have approximately the same mean.
+	knownK := 1.2
+	knownLambda := 80.0
+
+	samples := suite.GenWeibull(knownK, knownLambda, 5000, 555)
+	stats := NewStats(samples, true)
+
+	n := 50000
+	sum := 0.0
+
+	for range n {
+		dur := stats.Delay()
+		sum += float64(dur) / float64(time.Millisecond)
+	}
+
+	sampleMean := sum / float64(n)
+	expectedMean := knownLambda * math.Gamma(1.0+1.0/knownK)
+
+	suite.InDelta(expectedMean, sampleMean, expectedMean*0.05)
+}
+
+func (suite *StatsTestSuite) TestSizeStartPhase() {
+	stats := &Stats{k: 1.0, lambda: 1.0, drs: true}
+
+	for range TLSCounterAccelAfter {
+		size := stats.Size()
+		suite.GreaterOrEqual(size, TLSRecordSizeStart-DRSNoise)
+		suite.LessOrEqual(size, TLSRecordSizeStart)
+	}
+}
+
+func (suite *StatsTestSuite) TestSizeAccelPhase() {
+	stats := &Stats{k: 1.0, lambda: 1.0, drs: true}
+
+	for range TLSCounterAccelAfter {
+		stats.Size()
+	}
+
+	for range TLSCounterMaxAfter - TLSCounterAccelAfter {
+		size := stats.Size()
+		suite.GreaterOrEqual(size, TLSRecordSizeAccel-DRSNoise)
+		suite.LessOrEqual(size, TLSRecordSizeAccel)
+	}
+}
+
+func (suite *StatsTestSuite) TestSizeMaxPhase() {
+	stats := &Stats{k: 1.0, lambda: 1.0, drs: true}
+
+	for range TLSCounterMaxAfter {
+		stats.Size()
+	}
+
+	for range 20 {
+		size := stats.Size()
+		suite.Equal(TLSRecordSizeMax, size)
+	}
+}
+
+func (suite *StatsTestSuite) TestSizeResetsAfterInactivity() {
+	stats := &Stats{k: 1.0, lambda: 1.0, drs: true}
+
+	// Advance past start phase.
+	for range TLSCounterMaxAfter {
+		stats.Size()
+	}
+
+	suite.Equal(TLSRecordSizeMax, stats.Size())
+
+	// Simulate inactivity by backdating sizeLastRequested.
+	stats.sizeLastRequested = time.Now().Add(-TLSRecordSizeResetAfter - time.Millisecond)
+
+	size := stats.Size()
+	suite.GreaterOrEqual(size, TLSRecordSizeStart-DRSNoise)
+	suite.LessOrEqual(size, TLSRecordSizeStart)
+}
+
+func (suite *StatsTestSuite) TestSizeNoDRSAlwaysMax() {
+	stats := &Stats{k: 1.0, lambda: 1.0, drs: false}
+
+	for range TLSCounterMaxAfter + 20 {
+		suite.Equal(TLSRecordSizeMax, stats.Size())
+	}
+}
+
+func (suite *StatsTestSuite) TestSizeNoDRSIgnoresCounter() {
+	stats := &Stats{k: 1.0, lambda: 1.0, drs: false}
+
+	// Even after many calls, always returns max.
+	for range 200 {
+		suite.Equal(TLSRecordSizeMax, stats.Size())
+	}
+
+	// Inactivity has no effect either.
+	stats.sizeLastRequested = time.Now().Add(-TLSRecordSizeResetAfter - time.Millisecond)
+	suite.Equal(TLSRecordSizeMax, stats.Size())
+}
+
+func TestStats(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &StatsTestSuite{})
+}

mtglib/internal/faketls/client_hello.go

@@ -1,134 +0,0 @@
-package faketls
-
-import (
-	"crypto/hmac"
-	"crypto/sha256"
-	"crypto/subtle"
-	"encoding/binary"
-	"fmt"
-	"time"
-
-	"github.com/9seconds/mtg/v2/mtglib/internal/faketls/record"
-)
-
-type ClientHello struct {
-	Time        time.Time
-	Random      [RandomLen]byte
-	SessionID   []byte
-	Host        string
-	CipherSuite uint16
-}
-
-func (c ClientHello) Valid(hostname string, tolerateTimeSkewness time.Duration) error {
-	if c.Host != "" && c.Host != hostname {
-		return fmt.Errorf("incorrect hostname %s", hostname)
-	}
-
-	now := time.Now()
-
-	timeDiff := now.Sub(c.Time)
-	if timeDiff < 0 {
-		timeDiff = -timeDiff
-	}
-
-	if timeDiff > tolerateTimeSkewness {
-		return fmt.Errorf("incorrect timestamp. got=%d, now=%d, diff=%s",
-			c.Time.Unix(), now.Unix(), timeDiff.String())
-	}
-
-	return nil
-}
-
-func ParseClientHello(secret, handshake []byte) (ClientHello, error) {
-	hello := ClientHello{}
-
-	if len(handshake) < ClientHelloMinLen {
-		return hello, fmt.Errorf("lengh of handshake is too small: %d", len(handshake))
-	}
-
-	if handshake[0] != HandshakeTypeClient {
-		return hello, fmt.Errorf("unknown handshake type %#x", handshake[0])
-	}
-
-	handshakeSizeBytes := [4]byte{0, handshake[1], handshake[2], handshake[3]}
-	handshakeLength := binary.BigEndian.Uint32(handshakeSizeBytes[:])
-
-	if len(handshake)-4 != int(handshakeLength) {
-		return hello,
-			fmt.Errorf("incorrect handshake size. manifested=%d, real=%d",
-				handshakeLength, len(handshake)-4)
-	}
-
-	copy(hello.Random[:], handshake[ClientHelloRandomOffset:])
-	copy(handshake[ClientHelloRandomOffset:], clientHelloEmptyRandom)
-
-	rec := record.AcquireRecord()
-	defer record.ReleaseRecord(rec)
-
-	rec.Type = record.TypeHandshake
-	rec.Version = record.Version10
-	rec.Payload.Write(handshake)
-
-	// mac is calculated for the whole record, not only
-	// for the payload part
-	mac := hmac.New(sha256.New, secret)
-	rec.Dump(mac) //nolint: errcheck
-
-	computedRandom := mac.Sum(nil)
-
-	for i := 0; i < RandomLen; i++ {
-		computedRandom[i] ^= hello.Random[i]
-	}
-
-	if subtle.ConstantTimeCompare(clientHelloEmptyRandom[:RandomLen-4], computedRandom[:RandomLen-4]) != 1 {
-		return hello, ErrBadDigest
-	}
-
-	timestamp := int64(binary.LittleEndian.Uint32(computedRandom[RandomLen-4:]))
-	hello.Time = time.Unix(timestamp, 0)
-
-	parseSessionID(&hello, handshake)
-	parseCipherSuite(&hello, handshake)
-	parseSNI(&hello, handshake)
-
-	return hello, nil
-}
-
-func parseSessionID(hello *ClientHello, handshake []byte) {
-	hello.SessionID = make([]byte, handshake[ClientHelloSessionIDOffset])
-	copy(hello.SessionID, handshake[ClientHelloSessionIDOffset+1:])
-}
-
-func parseCipherSuite(hello *ClientHello, handshake []byte) {
-	cipherSuiteOffset := ClientHelloSessionIDOffset + len(hello.SessionID) + 3
-	hello.CipherSuite = binary.BigEndian.Uint16(handshake[cipherSuiteOffset : cipherSuiteOffset+2])
-}
-
-func parseSNI(hello *ClientHello, handshake []byte) {
-	cipherSuiteOffset := ClientHelloSessionIDOffset + len(hello.SessionID) + 1
-	handshake = handshake[cipherSuiteOffset:]
-
-	cipherSuiteLength := binary.BigEndian.Uint16(handshake[:2])
-	handshake = handshake[2+cipherSuiteLength:]
-
-	compressionMethodsLength := int(handshake[0])
-	handshake = handshake[1+compressionMethodsLength:]
-
-	extensionsLength := binary.BigEndian.Uint16(handshake[:2])
-	handshake = handshake[2 : 2+extensionsLength]
-
-	for len(handshake) > 0 {
-		if binary.BigEndian.Uint16(handshake[:2]) != ExtensionSNI {
-			extensionsLength := binary.BigEndian.Uint16(handshake[2:4])
-			handshake = handshake[4+extensionsLength:]
-
-			continue
-		}
-
-		hostnameLength := binary.BigEndian.Uint16(handshake[7:9])
-		handshake = handshake[9:]
-		hello.Host = string(handshake[:int(hostnameLength)])
-
-		return
-	}
-}

mtglib/internal/faketls/client_hello_fuzz_test.go

@@ -1,21 +0,0 @@
-package faketls_test
-
-import (
-	"testing"
-
-	"github.com/9seconds/mtg/v2/mtglib/internal/faketls"
-	"github.com/stretchr/testify/require"
-)
-
-var FuzzClientHelloSecret = []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
-
-func FuzzClientHello(f *testing.F) {
-	f.Add([]byte{1, 2, 3})
-
-	f.Fuzz(func(t *testing.T, frame []byte) {
-		_, err := faketls.ParseClientHello(FuzzClientHelloSecret, frame)
-
-		// a probability of having != err is almost negligible
-		require.Error(t, err)
-	})
-}

mtglib/internal/faketls/client_hello_test.go

@@ -1,191 +0,0 @@
-package faketls_test
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/9seconds/mtg/v2/mtglib"
-	"github.com/9seconds/mtg/v2/mtglib/internal/faketls"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type ClientHelloSnapshot struct {
-	Time        int    `json:"time"`
-	Random      string `json:"random"`
-	SessionID   string `json:"sessionId"`
-	Host        string `json:"host"`
-	CipherSuite int    `json:"cipherSuite"`
-	Full        string `json:"full"`
-}
-
-func (c ClientHelloSnapshot) GetTime() time.Time {
-	return time.Unix(int64(c.Time), 0)
-}
-
-func (c ClientHelloSnapshot) GetRandom() []byte {
-	data, _ := base64.StdEncoding.DecodeString(c.Random)
-
-	return data
-}
-
-func (c ClientHelloSnapshot) GetSessionID() []byte {
-	data, _ := base64.StdEncoding.DecodeString(c.SessionID)
-
-	return data
-}
-
-func (c ClientHelloSnapshot) GetHost() string {
-	return c.Host
-}
-
-func (c ClientHelloSnapshot) GetCipherSuite() uint16 {
-	return uint16(c.CipherSuite)
-}
-
-func (c ClientHelloSnapshot) GetFull() []byte {
-	data, _ := base64.StdEncoding.DecodeString(c.Full)
-
-	return data
-}
-
-type ClientHelloTestSuite struct {
-	suite.Suite
-
-	secret mtglib.Secret
-}
-
-func (suite *ClientHelloTestSuite) SetupSuite() {
-	parsed, err := mtglib.ParseSecret("ee367a189aee18fa31c190054efd4a8e9573746f726167652e676f6f676c65617069732e636f6d")
-	if err != nil {
-		panic(err)
-	}
-
-	suite.secret = parsed
-}
-
-func (suite *ClientHelloTestSuite) TestEmptyHandshake() {
-	_, err := faketls.ParseClientHello(suite.secret.Key[:], nil)
-	suite.Error(err)
-}
-
-func (suite *ClientHelloTestSuite) TestIncorrectHandshakeType() {
-	data := make([]byte, 1024)
-	data[0] = 0x02
-
-	_, err := faketls.ParseClientHello(suite.secret.Key[:], data)
-	suite.Error(err)
-}
-
-func (suite *ClientHelloTestSuite) TestIncorrectLength() {
-	data := make([]byte, 1024)
-	data[0] = 0x01
-	data[1] = 0xff
-	data[2] = 0xff
-
-	_, err := faketls.ParseClientHello(suite.secret.Key[:], data)
-	suite.Error(err)
-}
-
-func (suite *ClientHelloTestSuite) TestSnapshotOk() {
-	files, err := os.ReadDir("testdata")
-	suite.NoError(err)
-
-	testData := []string{}
-
-	for _, v := range files {
-		if strings.HasPrefix(v.Name(), "client-hello-ok") {
-			testData = append(testData, v.Name())
-		}
-	}
-
-	for _, name := range testData {
-		path := filepath.Join("testdata", name)
-
-		suite.T().Run(name, func(t *testing.T) {
-			fileData, err := os.ReadFile(path)
-			assert.NoError(t, err)
-
-			snapshot := &ClientHelloSnapshot{}
-			assert.NoError(t, json.Unmarshal(fileData, snapshot))
-
-			hello, err := faketls.ParseClientHello(suite.secret.Key[:], snapshot.GetFull())
-			assert.NoError(t, err)
-			assert.WithinDuration(t, snapshot.GetTime(), hello.Time, time.Second)
-			assert.Equal(t, snapshot.GetRandom(), hello.Random[:])
-			assert.Equal(t, snapshot.GetSessionID(), hello.SessionID)
-			assert.Equal(t, snapshot.GetHost(), hello.Host)
-			assert.Equal(t, snapshot.GetCipherSuite(), hello.CipherSuite)
-		})
-	}
-}
-
-func (suite *ClientHelloTestSuite) TestSnapshotBad() {
-	files, err := os.ReadDir("testdata")
-	suite.NoError(err)
-
-	testData := []string{}
-
-	for _, v := range files {
-		if strings.HasPrefix(v.Name(), "client-hello-bad") {
-			testData = append(testData, v.Name())
-		}
-	}
-
-	for _, name := range testData {
-		path := filepath.Join("testdata", name)
-
-		suite.T().Run(name, func(t *testing.T) {
-			fileData, err := os.ReadFile(path)
-			assert.NoError(t, err)
-
-			snapshot := &ClientHelloSnapshot{}
-			assert.NoError(t, json.Unmarshal(fileData, snapshot))
-
-			_, err = faketls.ParseClientHello(suite.secret.Key[:], snapshot.GetFull())
-			assert.Error(t, err)
-		})
-	}
-}
-
-func (suite *ClientHelloTestSuite) TestValidateHostname() {
-	hello := faketls.ClientHello{
-		Time: time.Now(),
-	}
-	suite.NoError(hello.Valid("hostname", time.Second))
-
-	hello.Host = "hostname"
-	suite.Error(hello.Valid("hostname2", time.Second))
-	suite.NoError(hello.Valid("hostname", time.Second))
-}
-
-func (suite *ClientHelloTestSuite) TestValidateTime() {
-	testData := []time.Duration{
-		-2 * time.Second,
-		2 * time.Second,
-	}
-
-	for _, v := range testData {
-		value := v
-
-		suite.T().Run(value.String(), func(t *testing.T) {
-			hello := faketls.ClientHello{
-				Host: "hostname",
-				Time: time.Now().Add(value),
-			}
-			suite.Error(hello.Valid("hostname", 500*time.Millisecond))
-			suite.Error(hello.Valid("hostname", time.Second))
-			suite.NoError(hello.Valid("hostname", 3*time.Second))
-		})
-	}
-}
-
-func TestClientHello(t *testing.T) {
-	t.Parallel()
-	suite.Run(t, &ClientHelloTestSuite{})
-}

mtglib/internal/faketls/conn.go

@@ -1,73 +0,0 @@
-package faketls
-
-import (
-	"bytes"
-	"fmt"
-	"math/rand"
-
-	"github.com/9seconds/mtg/v2/essentials"
-	"github.com/9seconds/mtg/v2/mtglib/internal/faketls/record"
-)
-
-type Conn struct {
-	essentials.Conn
-
-	readBuffer bytes.Buffer
-}
-
-func (c *Conn) Read(p []byte) (int, error) {
-	if n, _ := c.readBuffer.Read(p); n > 0 {
-		return n, nil
-	}
-
-	rec := record.AcquireRecord()
-	defer record.ReleaseRecord(rec)
-
-	for {
-		if err := rec.Read(c.Conn); err != nil {
-			return 0, err //nolint: wrapcheck
-		}
-
-		switch rec.Type { //nolint: exhaustive
-		case record.TypeApplicationData:
-			rec.Payload.WriteTo(&c.readBuffer) //nolint: errcheck
-
-			return c.readBuffer.Read(p) //nolint: wrapcheck
-		case record.TypeChangeCipherSpec:
-		default:
-			return 0, fmt.Errorf("unsupported record type %v", rec.Type)
-		}
-	}
-}
-
-func (c *Conn) Write(p []byte) (int, error) {
-	rec := record.AcquireRecord()
-	defer record.ReleaseRecord(rec)
-
-	rec.Type = record.TypeApplicationData
-	rec.Version = record.Version12
-
-	sendBuffer := acquireBytesBuffer()
-	defer releaseBytesBuffer(sendBuffer)
-
-	lenP := len(p)
-
-	for len(p) > 0 {
-		chunkSize := rand.Intn(record.TLSMaxRecordSize)
-		if chunkSize > len(p) || chunkSize == 0 {
-			chunkSize = len(p)
-		}
-
-		rec.Payload.Reset()
-		rec.Payload.Write(p[:chunkSize])
-		rec.Dump(sendBuffer) //nolint: errcheck
-
-		p = p[chunkSize:]
-	}
-
-	if _, err := c.Conn.Write(sendBuffer.Bytes()); err != nil {
-		return 0, err //nolint: wrapcheck
-	}
-
-	return lenP, nil
-}

mtglib/internal/faketls/conn_test.go

@@ -1,153 +0,0 @@
-package faketls_test
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"math/rand"
-	"testing"
-
-	"github.com/9seconds/mtg/v2/internal/testlib"
-	"github.com/9seconds/mtg/v2/mtglib/internal/faketls"
-	"github.com/9seconds/mtg/v2/mtglib/internal/faketls/record"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/suite"
-)
-
-type ConnMock struct {
-	testlib.EssentialsConnMock
-
-	readBuffer  bytes.Buffer
-	writeBuffer bytes.Buffer
-}
-
-func (m *ConnMock) Read(p []byte) (int, error) {
-	m.Called(p)
-
-	return m.readBuffer.Read(p) //nolint: wrapcheck
-}
-
-func (m *ConnMock) Write(p []byte) (int, error) {
-	m.Called(p)
-
-	return m.writeBuffer.Write(p) //nolint: wrapcheck
-}
-
-type ConnTestSuite struct {
-	suite.Suite
-
-	connMock *ConnMock
-	c        *faketls.Conn
-}
-
-func (suite *ConnTestSuite) SetupTest() {
-	suite.connMock = &ConnMock{}
-	suite.c = &faketls.Conn{
-		Conn: suite.connMock,
-	}
-}
-
-func (suite *ConnTestSuite) TearDownTest() {
-	suite.connMock.AssertExpectations(suite.T())
-}
-
-func (suite *ConnTestSuite) TestRead() {
-	suite.connMock.On("Read", mock.Anything).Return(0, nil)
-
-	rec := record.AcquireRecord()
-	defer record.ReleaseRecord(rec)
-
-	rec.Type = record.TypeChangeCipherSpec
-	rec.Version = record.Version12
-
-	rec.Payload.WriteByte(0x01)
-	rec.Dump(&suite.connMock.readBuffer) //nolint: errcheck
-	rec.Reset()
-
-	rec.Type = record.TypeApplicationData
-	rec.Version = record.Version12
-
-	rec.Payload.Write([]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
-	rec.Dump(&suite.connMock.readBuffer) //nolint: errcheck
-
-	resultBuffer := &bytes.Buffer{}
-	buf := make([]byte, 2)
-
-	for {
-		n, err := suite.c.Read(buf)
-		if errors.Is(err, io.EOF) {
-			break
-		}
-
-		resultBuffer.Write(buf[:n])
-	}
-
-	suite.Equal([]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, resultBuffer.Bytes())
-}
-
-func (suite *ConnTestSuite) TestReadUnexpected() {
-	suite.connMock.On("Read", mock.Anything).Return(0, nil)
-
-	rec := record.AcquireRecord()
-	defer record.ReleaseRecord(rec)
-
-	rec.Type = record.TypeChangeCipherSpec
-	rec.Version = record.Version12
-
-	rec.Payload.WriteByte(0x01)
-	rec.Dump(&suite.connMock.readBuffer) //nolint: errcheck
-	rec.Reset()
-
-	rec.Type = record.TypeHandshake
-	rec.Version = record.Version12
-
-	rec.Payload.Write([]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
-	rec.Dump(&suite.connMock.readBuffer) //nolint: errcheck
-
-	buf := make([]byte, 2)
-
-	for {
-		_, err := suite.c.Read(buf)
-
-		switch {
-		case err == nil:
-		case errors.Is(err, io.EOF):
-			suite.FailNow("unexpected to finish")
-		default:
-			return
-		}
-	}
-}
-
-func (suite *ConnTestSuite) TestWrite() {
-	suite.connMock.On("Write", mock.Anything).Return(0, nil)
-
-	dataToRec := make([]byte, record.TLSMaxRecordSize*2)
-	rand.Read(dataToRec) //nolint: staticcheck
-
-	n, err := suite.c.Write(dataToRec)
-	suite.NoError(err)
-	suite.Equal(len(dataToRec), n)
-
-	rec := record.AcquireRecord()
-	defer record.ReleaseRecord(rec)
-
-	buf := &bytes.Buffer{}
-
-	for {
-		if err := rec.Read(&suite.connMock.writeBuffer); err != nil {
-			break
-		}
-
-		suite.Equal(record.TypeApplicationData, rec.Type)
-		suite.Equal(record.Version12, rec.Version)
-		rec.Payload.WriteTo(buf) //nolint: errcheck
-	}
-
-	suite.Equal(dataToRec, buf.Bytes())
-}
-
-func TestConn(t *testing.T) {
-	t.Parallel()
-	suite.Run(t, &ConnTestSuite{})
-}

mtglib/internal/faketls/init.go

@@ -1,59 +0,0 @@
-package faketls
-
-import (
-	"bytes"
-	"errors"
-)
-
-const (
-	// RandomLen defines a size of the random digest in TLS Hellos.
-	RandomLen = 32
-
-	// ClientHelloRandomOffset is an offset in ClientHello record where
-	// random digest is started.
-	ClientHelloRandomOffset = 6
-
-	// ClientHelloSessionIDOffset is an offset in ClientHello record where
-	// SessionID is started.
-	ClientHelloSessionIDOffset = ClientHelloRandomOffset + RandomLen
-
-	// ClientHelloMinLen is a minimal possible length of
-	// ClientHello record.
-	ClientHelloMinLen = 6
-
-	// WelcomePacketRandomOffset is an offset of random in ServerHello
-	// packet (including record envelope).
-	WelcomePacketRandomOffset = 11
-
-	// HandshakeTypeClient is a value representing a client handshake.
-	HandshakeTypeClient = 0x01
-
-	// HandshakeTypeServer is a value representing a server handshake.
-	HandshakeTypeServer = 0x02
-
-	// ChangeCipherValue is a value representing a change cipher
-	// specification record.
-	ChangeCipherValue = 0x01
-
-	// ExtensionSNI is a value for TLS extension 'SNI'.
-	ExtensionSNI = 0x00
-)
-
-var (
-	// ErrBadDigest is returned if given TLS Client Hello mismatches with a
-	// derived one.
-	ErrBadDigest = errors.New("bad digest")
-
-	serverHelloSuffix = []byte{
-		0x00,       // no compression
-		0x00, 0x2e, // 46 bytes of data
-		0x00, 0x2b, // Extension - Supported Versions
-		0x00, 0x02, // 2 bytes are following
-		0x03, 0x04, // TLS 1.3
-		0x00, 0x33, // Extension - Key Share
-		0x00, 0x24, // 36 bytes
-		0x00, 0x1d, // x25519 curve
-		0x00, 0x20, // 32 bytes of key
-	}
-	clientHelloEmptyRandom = bytes.Repeat([]byte{0}, RandomLen)
-)

mtglib/internal/faketls/pools.go

@@ -1,21 +0,0 @@
-package faketls
-
-import (
-	"bytes"
-	"sync"
-)
-
-var bytesBufferPool = sync.Pool{
-	New: func() interface{} {
-		return &bytes.Buffer{}
-	},
-}
-
-func acquireBytesBuffer() *bytes.Buffer {
-	return bytesBufferPool.Get().(*bytes.Buffer) //nolint: forcetypeassert
-}
-
-func releaseBytesBuffer(b *bytes.Buffer) {
-	b.Reset()
-	bytesBufferPool.Put(b)
-}

mtglib/internal/faketls/record/init.go

@@ -1,84 +0,0 @@
-package record
-
-import "fmt"
-
-const TLSMaxRecordSize = 65535 // max uint16
-
-type Type uint8
-
-const (
-	// TypeChangeCipherSpec defines a byte value of the TLS record when a
-	// peer wants to change a specifications of the chosen cipher.
-	TypeChangeCipherSpec Type = 0x14
-
-	// TypeHandshake defines a byte value of the TLS record when a peer
-	// initiates a new TLS connection and wants to make a handshake
-	// ceremony.
-	TypeHandshake Type = 0x16
-
-	// TypeApplicationData defines a byte value of the TLS record when a
-	// peer sends an user data, not a control frames.
-	TypeApplicationData Type = 0x17
-)
-
-func (t Type) String() string {
-	switch t {
-	case TypeChangeCipherSpec:
-		return "changeCipher(0x14)"
-	case TypeHandshake:
-		return "handshake(0x16)"
-	case TypeApplicationData:
-		return "applicationData(0x17)"
-	}
-
-	return fmt.Sprintf("unknown(%#x)", byte(t))
-}
-
-func (t Type) Valid() error {
-	switch t {
-	case TypeChangeCipherSpec, TypeHandshake, TypeApplicationData:
-		return nil
-	}
-
-	return fmt.Errorf("unknown type %#x", byte(t))
-}
-
-type Version uint16
-
-const (
-	// Version10 defines a TLS1.0.
-	Version10 Version = 769 // 0x03 0x01
-
-	// Version11 defines a TLS1.1.
-	Version11 Version = 770 // 0x03 0x02
-
-	// Version12 defines a TLS1.2.
-	Version12 Version = 771 // 0x03 0x03
-
-	// Version13 defines a TLS1.3.
-	Version13 Version = 772 // 0x03 0x04
-)
-
-func (v Version) String() string {
-	switch v {
-	case Version10:
-		return "tls1.0"
-	case Version11:
-		return "tls1.1"
-	case Version12:
-		return "tls1.2"
-	case Version13:
-		return "tls1.3"
-	}
-
-	return fmt.Sprintf("tls?(%d)", uint16(v))
-}
-
-func (v Version) Valid() error {
-	switch v {
-	case Version10, Version11, Version12, Version13:
-		return nil
-	}
-
-	return fmt.Errorf("unknown version %d", uint16(v))
-}

mtglib/internal/faketls/record/init_test.go

@@ -1,79 +0,0 @@
-package record_test
-
-import (
-	"testing"
-
-	"github.com/9seconds/mtg/v2/mtglib/internal/faketls/record"
-	"github.com/stretchr/testify/suite"
-)
-
-type TypeTestSuite struct {
-	suite.Suite
-}
-
-func (suite *TypeTestSuite) TestChangeCipherSpec() {
-	suite.Contains(record.TypeChangeCipherSpec.String(), "changeCipher")
-	suite.Contains(record.TypeChangeCipherSpec.String(), "0x14")
-	suite.NoError(record.TypeChangeCipherSpec.Valid())
-}
-
-func (suite *TypeTestSuite) TestHandshake() {
-	suite.Contains(record.TypeHandshake.String(), "handshake")
-	suite.Contains(record.TypeHandshake.String(), "0x16")
-	suite.NoError(record.TypeHandshake.Valid())
-}
-
-func (suite *TypeTestSuite) TestApplicationData() {
-	suite.Contains(record.TypeApplicationData.String(), "applicationData")
-	suite.Contains(record.TypeApplicationData.String(), "0x17")
-	suite.NoError(record.TypeApplicationData.Valid())
-}
-
-func (suite *TypeTestSuite) TestUnknown() {
-	value := record.Type(0x20)
-
-	suite.Contains(value.String(), "unknown")
-	suite.Contains(value.String(), "0x20")
-	suite.Error(value.Valid())
-}
-
-type VersionTestSuite struct {
-	suite.Suite
-}
-
-func (suite *VersionTestSuite) Test10() {
-	suite.Equal("tls1.0", record.Version10.String())
-	suite.NoError(record.Version10.Valid())
-}
-
-func (suite *VersionTestSuite) Test11() {
-	suite.Equal("tls1.1", record.Version11.String())
-	suite.NoError(record.Version11.Valid())
-}
-
-func (suite *VersionTestSuite) Test12() {
-	suite.Equal("tls1.2", record.Version12.String())
-	suite.NoError(record.Version12.Valid())
-}
-
-func (suite *VersionTestSuite) Test13() {
-	suite.Equal("tls1.3", record.Version13.String())
-	suite.NoError(record.Version13.Valid())
-}
-
-func (suite *VersionTestSuite) TestUnknown() {
-	value := record.Version(900)
-
-	suite.Equal("tls?(900)", value.String())
-	suite.Error(value.Valid())
-}
-
-func TestType(t *testing.T) {
-	t.Parallel()
-	suite.Run(t, &TypeTestSuite{})
-}
-
-func TestVersion(t *testing.T) {
-	t.Parallel()
-	suite.Run(t, &VersionTestSuite{})
-}

mtglib/internal/faketls/record/pools.go

@@ -1,20 +0,0 @@
-package record
-
-import (
-	"sync"
-)
-
-var recordPool = sync.Pool{
-	New: func() interface{} {
-		return &Record{}
-	},
-}
-
-func AcquireRecord() *Record {
-	return recordPool.Get().(*Record) //nolint: forcetypeassert
-}
-
-func ReleaseRecord(r *Record) {
-	r.Reset()
-	recordPool.Put(r)
-}

mtglib/internal/faketls/record/record.go

@@ -1,86 +0,0 @@
-package record
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/binary"
-	"fmt"
-	"io"
-)
-
-type Record struct {
-	Type    Type
-	Version Version
-	Payload bytes.Buffer
-}
-
-func (r *Record) String() string {
-	return fmt.Sprintf("<tlsRecord(type=%v, version=%v, payload=%s)>",
-		r.Type,
-		r.Version,
-		base64.StdEncoding.EncodeToString(r.Payload.Bytes()))
-}
-
-func (r *Record) Reset() {
-	r.Payload.Reset()
-}
-
-func (r *Record) Read(reader io.Reader) error {
-	r.Reset()
-
-	buf := [2]byte{}
-
-	if _, err := io.ReadFull(reader, buf[:1]); err != nil {
-		return fmt.Errorf("cannot read type: %w", err)
-	}
-
-	r.Type = Type(buf[0])
-	if err := r.Type.Valid(); err != nil {
-		return fmt.Errorf("invalid type: %w", err)
-	}
-
-	if _, err := io.ReadFull(reader, buf[:]); err != nil {
-		return fmt.Errorf("cannot read version: %w", err)
-	}
-
-	r.Version = Version(binary.BigEndian.Uint16(buf[:]))
-	if err := r.Version.Valid(); err != nil {
-		return fmt.Errorf("invalid version: %w", err)
-	}
-
-	if _, err := io.ReadFull(reader, buf[:]); err != nil {
-		return fmt.Errorf("cannot read payload length: %w", err)
-	}
-
-	length := int64(binary.BigEndian.Uint16(buf[:]))
-	if _, err := io.CopyN(&r.Payload, reader, length); err != nil {
-		return fmt.Errorf("cannot read payload: %w", err)
-	}
-
-	return nil
-}
-
-func (r *Record) Dump(writer io.Writer) error {
-	buf := [2]byte{byte(r.Type), 0}
-	if _, err := writer.Write(buf[:1]); err != nil {
-		return fmt.Errorf("cannot dump record type: %w", err)
-	}
-
-	binary.BigEndian.PutUint16(buf[:], uint16(r.Version))
-
-	if _, err := writer.Write(buf[:]); err != nil {
-		return fmt.Errorf("cannot dump version: %w", err)
-	}
-
-	binary.BigEndian.PutUint16(buf[:], uint16(r.Payload.Len()))
-
-	if _, err := writer.Write(buf[:]); err != nil {
-		return fmt.Errorf("cannot dump payload length: %w", err)
-	}
-
-	if _, err := writer.Write(r.Payload.Bytes()); err != nil {
-		return fmt.Errorf("cannot dump record: %w", err)
-	}
-
-	return nil
-}

mtglib/internal/faketls/record/record_test.go

@@ -1,110 +0,0 @@
-package record_test
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/9seconds/mtg/v2/mtglib/internal/faketls/record"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type RecordTestSnapshot struct {
-	Type    int    `json:"type"`
-	Version int    `json:"version"`
-	Payload string `json:"payload"`
-	Record  string `json:"record"`
-}
-
-func (r RecordTestSnapshot) RecordBytes() []byte {
-	data, _ := base64.StdEncoding.DecodeString(r.Record)
-
-	return data
-}
-
-func (r RecordTestSnapshot) PayloadBytes() []byte {
-	data, _ := base64.StdEncoding.DecodeString(r.Payload)
-
-	return data
-}
-
-type RecordTestSuite struct {
-	suite.Suite
-
-	r   *record.Record
-	buf *bytes.Buffer
-}
-
-func (suite *RecordTestSuite) SetupTest() {
-	suite.r = record.AcquireRecord()
-	suite.buf = &bytes.Buffer{}
-}
-
-func (suite *RecordTestSuite) TearDownTest() {
-	record.ReleaseRecord(suite.r)
-	suite.buf.Reset()
-}
-
-func (suite *RecordTestSuite) TestIdempotent() {
-	suite.r.Type = record.TypeApplicationData
-	suite.r.Version = record.Version13
-
-	suite.r.Payload.Write([]byte{1, 2, 3})
-	suite.NoError(suite.r.Dump(suite.buf))
-
-	suite.r.Reset()
-	suite.NoError(suite.r.Read(suite.buf))
-
-	suite.Equal(0, suite.buf.Len())
-	suite.Equal(record.TypeApplicationData, suite.r.Type)
-	suite.Equal(record.Version13, suite.r.Version)
-	suite.Equal([]byte{1, 2, 3}, suite.r.Payload.Bytes())
-}
-
-func (suite *RecordTestSuite) TestString() {
-	_ = suite.r.String()
-}
-
-func (suite *RecordTestSuite) TestSnapshot() {
-	files, err := os.ReadDir("testdata")
-	suite.NoError(err)
-
-	testData := map[string]string{}
-
-	for _, f := range files {
-		testData[f.Name()] = filepath.Join("testdata", f.Name())
-	}
-
-	for name, pathV := range testData {
-		path := pathV
-
-		suite.T().Run(name, func(t *testing.T) {
-			data, err := os.ReadFile(path)
-			assert.NoError(t, err)
-
-			snapshot := &RecordTestSnapshot{}
-			assert.NoError(t, json.Unmarshal(data, snapshot))
-
-			rec := record.AcquireRecord()
-			defer record.ReleaseRecord(rec)
-
-			assert.NoError(t, rec.Read(bytes.NewReader(snapshot.RecordBytes())))
-			assert.Equal(t, snapshot.Type, int(rec.Type))
-			assert.Equal(t, snapshot.Version, int(rec.Version))
-			assert.Equal(t, snapshot.PayloadBytes(), rec.Payload.Bytes())
-
-			buf := &bytes.Buffer{}
-			assert.NoError(t, rec.Dump(buf))
-			assert.Equal(t, snapshot.RecordBytes(), buf.Bytes())
-		})
-	}
-}
-
-func TestRecord(t *testing.T) {
-	t.Parallel()
-	suite.Run(t, &RecordTestSuite{})
-}

mtglib/internal/faketls/record/testdata/05eb6b71f87b6802.json

@@ -1,6 +0,0 @@
-{
-  "type": 20,
-  "version": 772,
-  "payload": "sxS+0oAyk+NBv0LLVtQOp9WSx4CweyUZPz01tQ0o4oyp8aaBl6/kMFvLq3q52KE8lCiKejLw2NxVBUkE+4izCf2gLx9qfr81opWnqJTChWzcDijvttbq9cmtDFNL+odKsS3v1/TfYEFtPsoRPrJRmOHRAnqnf49Y5Q==",
-  "record": "FAMEAHmzFL7SgDKT40G/QstW1A6n1ZLHgLB7JRk/PTW1DSjijKnxpoGXr+QwW8urernYoTyUKIp6MvDY3FUFSQT7iLMJ/aAvH2p+vzWilaeolMKFbNwOKO+21ur1ya0MU0v6h0qxLe/X9N9gQW0+yhE+slGY4dECeqd/j1jl"
-}

mtglib/internal/faketls/record/testdata/4eef4abc15b206b6.json

@@ -1,6 +0,0 @@
-{
-  "type": 22,
-  "version": 772,
-  "payload": "waNH223htyxCBKAb6hm0u/SK/9mhI8Ck91nfWob7QMOaIREogrDYREJH4Djcp47XrpAlEaUIDiCvoFLVJ/LK1nYs4swzfHSSl/+Aj1eqPA63XqPa8EG4FAbf0DwjwXxV9qVIhvP9b2TafKbzr4Yb5GCygzFRb/zawA==",
-  "record": "FgMEAHnBo0fbbeG3LEIEoBvqGbS79Ir/2aEjwKT3Wd9ahvtAw5ohESiCsNhEQkfgONynjteukCURpQgOIK+gUtUn8srWdizizDN8dJKX/4CPV6o8Drdeo9rwQbgUBt/QPCPBfFX2pUiG8/1vZNp8pvOvhhvkYLKDMVFv/NrA"
-}

mtglib/internal/faketls/record/testdata/736f358216afe91f.json

@@ -1,6 +0,0 @@
-{
-  "type": 23,
-  "version": 769,
-  "payload": "jmJ0o1E5+ehAHHYAbCo4AMV03X7RSivYl250s06nD9CO44fyjaoGELz0N7IeCg1jFKcRVSCRmYYmiIY9wydn2fXOJhKif8B0BlM3qhbethYgyP+l1S8hyyETpIiOtiiiOnAJwl1D1j9OryFiJFSdRRXReIMZ4CPqPg==",
-  "record": "FwMBAHmOYnSjUTn56EAcdgBsKjgAxXTdftFKK9iXbnSzTqcP0I7jh/KNqgYQvPQ3sh4KDWMUpxFVIJGZhiaIhj3DJ2fZ9c4mEqJ/wHQGUzeqFt62FiDI/6XVLyHLIROkiI62KKI6cAnCXUPWP06vIWIkVJ1FFdF4gxngI+o+"
-}

mtglib/internal/faketls/record/testdata/8405d94222bd0b6a.json

@@ -1,6 +0,0 @@
-{
-  "type": 22,
-  "version": 769,
-  "payload": "hBnpBnNUdlqe/rKXa7Judcz79u7AkUgSGOycn8EqvbkZpVxnI31rNOvAsPZqG+GF7DWJ3R7H2ETmFmrpnyyng32MjSs1jptmV1oAs63zTADD7sVipgid9AJHwfl4CrC3FIQr43IPMYd29JPOl5bqu/SfrgI16PBiJw==",
-  "record": "FgMBAHmEGekGc1R2Wp7+spdrsm51zPv27sCRSBIY7JyfwSq9uRmlXGcjfWs068Cw9mob4YXsNYndHsfYROYWaumfLKeDfYyNKzWOm2ZXWgCzrfNMAMPuxWKmCJ30AkfB+XgKsLcUhCvjcg8xh3b0k86Xluq79J+uAjXo8GIn"
-}

mtglib/internal/faketls/record/testdata/9036f76e517f0cd1.json

@@ -1,6 +0,0 @@
-{
-  "type": 23,
-  "version": 770,
-  "payload": "Vm/C+DO56czlbtR915aHzsugSyDtp8CtojF9w1jKY0efyyfcLrNuhNg/pZm3gQ7v2BBbL1UJ97v/RIjST+5gRIfg3bBN1BE9hkf+N2AYY2lHLi0yeInHB0zFWPeHscsDopDFadIi5KtC8HvbEMuK+kK8POVk5tN9UQ==",
-  "record": "FwMCAHlWb8L4M7npzOVu1H3XlofOy6BLIO2nwK2iMX3DWMpjR5/LJ9wus26E2D+lmbeBDu/YEFsvVQn3u/9EiNJP7mBEh+DdsE3UET2GR/43YBhjaUcuLTJ4iccHTMVY94exywOikMVp0iLkq0Lwe9sQy4r6Qrw85WTm031R"
-}

mtglib/internal/faketls/record/testdata/9244766a0fe4a02a.json

@@ -1,6 +0,0 @@
-{
-  "type": 22,
-  "version": 770,
-  "payload": "ajPzpsgk4gwm2stRQKbllvKRLdI7vmyaj1uxEJ/kKoQnQSPumdDNKD618U2Cq6PVd0/b+9YtH67Uzx1QxtpKuby5fUXqw06WUuDAQsmjq7F26EkE5FND6rQUjUPC+e1U0dF4TQzOUSS4IAkFQPAaVehUVTRxVWa/0g==",
-  "record": "FgMCAHlqM/OmyCTiDCbay1FApuWW8pEt0ju+bJqPW7EQn+QqhCdBI+6Z0M0oPrXxTYKro9V3T9v71i0frtTPHVDG2kq5vLl9RerDTpZS4MBCyaOrsXboSQTkU0PqtBSNQ8L57VTR0XhNDM5RJLggCQVA8BpV6FRVNHFVZr/S"
-}

mtglib/internal/faketls/record/testdata/9255c73d3de76e7b.json

@@ -1,6 +0,0 @@
-{
-  "type": 20,
-  "version": 771,
-  "payload": "d1Hiv1NYVgEDR9mtJyv9j8mg3dWqfUpeKfOsL+jzSDfVIxeDiJZFLDT50TjNW44/yEOVEX/Y/pk+wnc7E8aCEiwGwAvB+Insw1UCJ2ejt689VWLo2u4klGVKTHuOpUvdGVTc7Lo4FAt91KQSPLYB5iqxomjEv5e3Vg==",
-  "record": "FAMDAHl3UeK/U1hWAQNH2a0nK/2PyaDd1ap9Sl4p86wv6PNIN9UjF4OIlkUsNPnROM1bjj/IQ5URf9j+mT7CdzsTxoISLAbAC8H4iezDVQInZ6O3rz1VYuja7iSUZUpMe46lS90ZVNzsujgUC33UpBI8tgHmKrGiaMS/l7dW"
-}

mtglib/internal/faketls/record/testdata/aeb65b9924315cf8.json

@@ -1,6 +0,0 @@
-{
-  "type": 23,
-  "version": 771,
-  "payload": "wbdU1CbrzuAJDsh6CFjGyE+AFArJj/Wmsa2wtDyW0kRuE2vUO8gg+nXkg0kkoz0WnvQEOdaswfJIaVrloD78yoyeQVfBB+VUP/63vqn60v5ccaQEn0jLdxgLjiTAxKDQDxCTMRoLnFE2ZZf28zw+HfqpIxiOZs8LhQ==",
-  "record": "FwMDAHnBt1TUJuvO4AkOyHoIWMbIT4AUCsmP9aaxrbC0PJbSRG4Ta9Q7yCD6deSDSSSjPRae9AQ51qzB8khpWuWgPvzKjJ5BV8EH5VQ//re+qfrS/lxxpASfSMt3GAuOJMDEoNAPEJMxGgucUTZll/bzPD4d+qkjGI5mzwuF"
-}

mtglib/internal/faketls/record/testdata/b0acd44296056b54.json

@@ -1,6 +0,0 @@
-{
-  "type": 23,
-  "version": 772,
-  "payload": "qqnBMb1Af3zZt4DPHpVRuIiON9ODGJUNFicFjranORh67L/HI4D6HnHyycZFUSBOw2FjMBF6UialY8snOYaRKrQmQzuUNg1Ztq7yAZ+Lgj3TBarR6OMlYhEAY0Px9Xv1UuJ0YcvQx33gdM1skJ5HBR3yZvEKNJV1LA==",
-  "record": "FwMEAHmqqcExvUB/fNm3gM8elVG4iI4304MYlQ0WJwWOtqc5GHrsv8cjgPoecfLJxkVRIE7DYWMwEXpSJqVjyyc5hpEqtCZDO5Q2DVm2rvIBn4uCPdMFqtHo4yViEQBjQ/H1e/VS4nRhy9DHfeB0zWyQnkcFHfJm8Qo0lXUs"
-}

mtglib/internal/faketls/record/testdata/c0545a13fd9a3fa3.json

@@ -1,6 +0,0 @@
-{
-  "type": 20,
-  "version": 769,
-  "payload": "NEe735TuQFp7bWpFQhASas/e1XaySvus0ovXmkfCbFq334MyFHq2eDMadziXsfu/GfBjoYggvk0LgYUeoAkBNKR0dfSovjSndaqmIUonoWl+6sZObiGZkRIMwuY2q4Eaw4/iuDu/pZhjRW/iAIH+YH7cyk/1tgdJDg==",
-  "record": "FAMBAHk0R7vflO5AWnttakVCEBJqz97VdrJK+6zSi9eaR8JsWrffgzIUerZ4Mxp3OJex+78Z8GOhiCC+TQuBhR6gCQE0pHR19Ki+NKd1qqYhSiehaX7qxk5uIZmREgzC5jargRrDj+K4O7+lmGNFb+IAgf5gftzKT/W2B0kO"
-}

mtglib/internal/faketls/record/testdata/f083f4501668b759.json

@@ -1,6 +0,0 @@
-{
-  "type": 22,
-  "version": 771,
-  "payload": "wrXjZrPm3OSyzO0klv6/G+z2PDloR/colS/RlWwQE31Vb2xm8YkEchDDKwlc/KPLD73qMoz3MQOQLtSLc8LhVYp+l7L9jz49yTaVKtBI5UuGbo09snsKxFCgCyYUBETKabATBQtiaEu/D8dmF4Yk/2ww4sEb8DwKLQ==",
-  "record": "FgMDAHnCteNms+bc5LLM7SSW/r8b7PY8OWhH9yiVL9GVbBATfVVvbGbxiQRyEMMrCVz8o8sPveoyjPcxA5Au1ItzwuFVin6Xsv2PPj3JNpUq0EjlS4ZujT2yewrEUKALJhQERMppsBMFC2JoS78Px2YXhiT/bDDiwRvwPAot"
-}