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

.gitattributes

@@ -1,3 +0,0 @@
-# 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

@@ -119,39 +119,6 @@ jobs:
       - 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

.github/workflows/codeql-analysis.yml

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

.goreleaser.yml

@@ -10,15 +10,13 @@ before:
     - go generate ./...
 
 builds:
-  - id: default
-    binary: '{{ .ProjectName }}'
+  - binary: '{{ .ProjectName }}'
     goos:
       - darwin
       - freebsd
       - linux
       - netbsd
       - openbsd
-      - windows
     goarch:
       - 386
       - amd64
@@ -36,92 +34,15 @@ 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:
-  - id: default
-    ids:
-      - default
-      - mips
-    name_template: '{{ .ProjectName }}-{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ 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
-  - id: optimized
-    ids:
-      - arm64-v9
-      - amd64-v3
-    name_template: '{{ .ProjectName }}-{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm64 }}-{{ .Arm64 }}{{ end }}{{ if .Amd64 }}-{{ .Amd64 }}{{ end }}'
+  - name_template: '{{ .ProjectName }}-{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}'
     formats:
       - tar.gz
     wrap_in_directory: true

.mise.toml

@@ -16,12 +16,6 @@ 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 = [

Dockerfile

@@ -5,19 +5,6 @@ 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 \
-  && mkdir -p /config \
-  && ln -sv /config.toml /config/config.toml
-
 RUN --mount=type=cache,target=/var/cache/apk \
     set -x \
     && apk --update add \
@@ -33,7 +20,7 @@ RUN go mod download
 COPY . /app
 
 RUN set -x \
-  && version="$(git describe --exact-match HEAD 2>/dev/null || git describe --tags --always 2>/dev/null || echo dev)" \
+  && version="$(git describe --exact-match HEAD 2>/dev/null || git describe --tags --always)" \
   && go build \
       -trimpath \
       -mod=readonly \
@@ -48,9 +35,8 @@ RUN set -x \
 FROM scratch
 
 ENTRYPOINT ["/mtg"]
-CMD ["run", "/config/config.toml"]
+CMD ["run", "/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

@@ -29,8 +29,6 @@ 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
@@ -93,9 +91,6 @@ that probably matter.
   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.
@@ -306,38 +301,6 @@ 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
 
@@ -417,7 +380,6 @@ ExecStart=/usr/local/bin/mtg run /etc/mtg.toml
 Restart=always
 RestartSec=3
 DynamicUser=true
-LimitNOFILE=65536
 AmbientCapabilities=CAP_NET_BIND_SERVICE
 
 [Install]

antireplay/stable_bloom_filter_test.go

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

essentials/addresses.go

@@ -1,30 +0,0 @@
-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",
-	},
-}

events/event_stream.go

@@ -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[chanNo%uint32(len(e.chans))] <- evt:
+	case e.chans[int(chanNo)%len(e.chans)] <- evt:
 	}
 }
 

example.config.toml

@@ -48,13 +48,6 @@ 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.
@@ -204,22 +197,14 @@ proxies = [
 # define a global timeout on establishing of network connections. idle
 # means a timeout on pumping data between sockset when nothing is
 # happening.
+#
+# please be noticed that handshakes have no timeouts intentionally. You can
+# find a reasoning here:
+# https://www.ndss-symposium.org/wp-content/uploads/2020/02/23087-paper.pdf
 [network.timeout]
 tcp = "5s"
 http = "10s"
-idle = "5m"
-handshake = "10s"
-
-# this defines a configuration for TCP keep alives. Default values are taken
-# from Golang default behavior.
-[network.keep-alive]
-disabled = false
-# idle means a time period after which we start sending TCP Keep Alive probes
-idle = "15s"
-# interval is a period between 2 consecutive probes
-interval = "15s"
-# if we miss that many probes, a connection will be considered as a dead one.
-count = 9
+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.

go.mod

@@ -4,18 +4,18 @@ go 1.26
 
 require (
 	github.com/OneOfOne/xxhash v1.2.8
-	github.com/alecthomas/kong v1.15.0
+	github.com/alecthomas/kong v1.14.0
 	github.com/alecthomas/units v0.0.0-20240927000941-0f3dac36c52b
 	github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5
 	github.com/babolivier/go-doh-client v0.0.0-20201028162107-a76cff4cb8b6
 	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.12.0
+	github.com/panjf2000/ants/v2 v2.11.6
 	github.com/prometheus/client_golang v1.23.2
 	github.com/prometheus/common v0.67.5 // indirect
 	github.com/prometheus/procfs v0.20.1 // indirect
-	github.com/rs/zerolog v1.35.0
+	github.com/rs/zerolog v1.34.0
 	github.com/smira/go-statsd v1.3.4
 	github.com/stretchr/objx v0.5.2 // indirect
 	github.com/stretchr/testify v1.11.1
@@ -27,9 +27,8 @@ require (
 )
 
 require (
-	github.com/beevik/ntp v1.5.0
-	github.com/ncruces/go-dns v1.3.3
-	github.com/pelletier/go-toml/v2 v2.3.0
+	github.com/ncruces/go-dns v1.3.2
+	github.com/pelletier/go-toml/v2 v2.2.4
 	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

go.sum

@@ -2,8 +2,8 @@ github.com/OneOfOne/xxhash v1.2.8 h1:31czK/TI9sNkxIKfaUfGlU47BAxQ0ztGgd9vPyqimf8
 github.com/OneOfOne/xxhash v1.2.8/go.mod h1:eZbhyaAYD41SGSSsnmcpxVoRiQ/MPUTjUdIIOT9Um7Q=
 github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0=
 github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
-github.com/alecthomas/kong v1.15.0 h1:BVJstKbpO73zKpmIu+m/aLRrNmWwxXPIGTNin9VmLVI=
-github.com/alecthomas/kong v1.15.0/go.mod h1:wrlbXem1CWqUV5Vbmss5ISYhsVPkBb1Yo7YKJghju2I=
+github.com/alecthomas/kong v1.14.0 h1:gFgEUZWu2ZmZ+UhyZ1bDhuutbKN1nTtJTwh19Wsn21s=
+github.com/alecthomas/kong v1.14.0/go.mod h1:wrlbXem1CWqUV5Vbmss5ISYhsVPkBb1Yo7YKJghju2I=
 github.com/alecthomas/repr v0.5.2 h1:SU73FTI9D1P5UNtvseffFSGmdNci/O6RsqzeXJtP0Qs=
 github.com/alecthomas/repr v0.5.2/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
 github.com/alecthomas/units v0.0.0-20240927000941-0f3dac36c52b h1:mimo19zliBX/vSQ6PWWSL9lK8qwHozUj03+zLoEB8O0=
@@ -12,18 +12,18 @@ 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=
@@ -38,8 +38,11 @@ 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=
@@ -48,16 +51,17 @@ 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/ncruces/go-dns v1.3.3 h1:59OV7XoJrTCoUMZjWRVs4GOjtntMTZqiQ5Mn+BT13hk=
-github.com/ncruces/go-dns v1.3.3/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/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.11.6 h1:JKsoIUukIoCO0sP0gcOqdyoXmpyKXuU6fC57rODtpug=
+github.com/panjf2000/ants/v2 v2.11.6/go.mod h1:8u92CYMUc6gyvTIw8Ru7Mt7+/ESnJahz5EVtqfrilek=
 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/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/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
+github.com/pelletier/go-toml/v2 v2.2.4/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/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 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=
@@ -70,8 +74,9 @@ github.com/prometheus/procfs v0.20.1 h1:XwbrGOIplXW/AU3YhIhLODXMJYyC1isLFfYCsTEy
 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/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/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=
@@ -126,8 +131,10 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-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.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=

internal/cli/access.go

@@ -1,16 +1,22 @@
 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 {
@@ -59,10 +65,7 @@ func (a *Access) Run(cli *CLI, version string) error {
 	wg.Go(func() {
 		ip := a.PublicIPv4
 		if ip == nil {
-			ip = conf.PublicIPv4.Get(nil)
-		}
-		if ip == nil {
-			ip = getIP(ntw, "tcp4")
+			ip = a.getIP(ntw, "tcp4")
 		}
 
 		if ip != nil {
@@ -74,10 +77,7 @@ func (a *Access) Run(cli *CLI, version string) error {
 	wg.Go(func() {
 		ip := a.PublicIPv6
 		if ip == nil {
-			ip = conf.PublicIPv6.Get(nil)
-		}
-		if ip == nil {
-			ip = getIP(ntw, "tcp6")
+			ip = a.getIP(ntw, "tcp6")
 		}
 
 		if ip != nil {
@@ -100,6 +100,45 @@ func (a *Access) Run(cli *CLI, version string) error {
 	return nil
 }
 
+func (a *Access) 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)))
+}
+
 func (a *Access) makeURLs(conf *config.Config, ip net.IP) *accessResponseURLs {
 	if ip == nil {
 		return nil

internal/cli/cli.go

@@ -4,7 +4,6 @@ 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

@@ -1,381 +0,0 @@
-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),
-		net.KeepAliveConfig{
-			Enable:   !conf.Network.KeepAlive.Disabled.Get(false),
-			Idle:     conf.Network.KeepAlive.Idle.Get(0),
-			Interval: conf.Network.KeepAlive.Interval.Get(0),
-			Count:    int(conf.Network.KeepAlive.Count.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

@@ -50,12 +50,6 @@ func makeNetwork(conf *config.Config, version string) (mtglib.Network, error) {
 		conf.Network.Timeout.TCP.Get(0),
 		conf.Network.Timeout.HTTP.Get(0),
 		conf.Network.Timeout.Idle.Get(0),
-		net.KeepAliveConfig{
-			Enable:   !conf.Network.KeepAlive.Disabled.Get(false),
-			Idle:     conf.Network.KeepAlive.Idle.Get(0),
-			Interval: conf.Network.KeepAlive.Interval.Get(0),
-			Count:    int(conf.Network.KeepAlive.Count.Get(0)),
-		},
 	)
 
 	proxyDialers := make([]mtglib.Network, len(conf.Network.Proxies))
@@ -259,7 +253,6 @@ func runProxy(conf *config.Config, version string) error { //nolint: funlen
 		EventStream:     eventStream,
 
 		Secret:                      conf.Secret,
-		Concurrency:                 conf.GetConcurrency(mtglib.DefaultConcurrency),
 		DomainFrontingPort:          conf.GetDomainFrontingPort(mtglib.DefaultDomainFrontingPort),
 		DomainFrontingIP:            conf.GetDomainFrontingIP(nil),
 		DomainFrontingProxyProtocol: conf.GetDomainFrontingProxyProtocol(false),
@@ -268,8 +261,6 @@ func runProxy(conf *config.Config, version string) error { //nolint: funlen
 
 		AllowFallbackOnUnknownDC: conf.AllowFallbackOnUnknownDC.Get(false),
 		TolerateTimeSkewness:     conf.TolerateTimeSkewness.Value,
-		IdleTimeout:              conf.Network.Timeout.Idle.Get(mtglib.DefaultIdleTimeout),
-		HandshakeTimeout:         conf.Network.Timeout.Handshake.Get(mtglib.DefaultHandshakeTimeout),
 
 		DoppelGangerURLs:    doppelGangerURLs,
 		DoppelGangerPerRaid: conf.Defense.Doppelganger.Repeats.Get(mtglib.DoppelGangerPerRaid),

internal/cli/utils.go

@@ -1,51 +0,0 @@
-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

@@ -35,8 +35,6 @@ type Config struct {
 	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"`
@@ -60,17 +58,10 @@ type Config struct {
 	} `json:"defense"`
 	Network struct {
 		Timeout struct {
-			TCP       TypeDuration `json:"tcp"`
-			HTTP      TypeDuration `json:"http"`
-			Idle      TypeDuration `json:"idle"`
-			Handshake TypeDuration `json:"handshake"`
+			TCP  TypeDuration `json:"tcp"`
+			HTTP TypeDuration `json:"http"`
+			Idle TypeDuration `json:"idle"`
 		} `json:"timeout"`
-		KeepAlive struct {
-			Disabled TypeBool        `json:"disabled"`
-			Idle     TypeDuration    `json:"idle"`
-			Interval TypeDuration    `json:"interval"`
-			Count    TypeConcurrency `json:"count"`
-		} `json:"keepAlive"`
 		DOHIP   TypeIP         `json:"dohIp"`
 		DNS     TypeDNSURI     `json:"dns"`
 		Proxies []TypeProxyURL `json:"proxies"`
@@ -93,13 +84,6 @@ 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
 

internal/config/config_test.go

@@ -42,32 +42,6 @@ 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

@@ -21,8 +21,6 @@ type tomlConfig struct {
 	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"`
@@ -55,17 +53,10 @@ type tomlConfig struct {
 	} `toml:"defense" json:"defense,omitempty"`
 	Network struct {
 		Timeout struct {
-			TCP       string `toml:"tcp" json:"tcp,omitempty"`
-			HTTP      string `toml:"http" json:"http,omitempty"`
-			Idle      string `toml:"idle" json:"idle,omitempty"`
-			Handshake string `toml:"handshake" json:"handshake,omitempty"`
+			TCP  string `toml:"tcp" json:"tcp,omitempty"`
+			HTTP string `toml:"http" json:"http,omitempty"`
+			Idle string `toml:"idle" json:"idle,omitempty"`
 		} `toml:"timeout" json:"timeout,omitempty"`
-		KeepAlive struct {
-			Disabled bool   `toml:"disabled" json:"disabled,omitempty"`
-			Idle     string `toml:"idle" json:"idle,omitempty"`
-			Interval string `toml:"interval" json:"interval,omitempty"`
-			Count    uint   `toml:"count" json:"count,omitempty"`
-		} `toml:"keep-alive" json:"keepAlive,omitempty"`
 		DOHIP   string   `toml:"doh-ip" json:"dohIp,omitempty"`
 		DNS     string   `toml:"dns" json:"dns,omitempty"`
 		Proxies []string `toml:"proxies" json:"proxies,omitempty"`

internal/config/testdata/public_ip.toml

@@ -1,4 +0,0 @@
-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

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

internal/config/testdata/public_ip_v4_only.toml

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

main.go

@@ -14,23 +14,6 @@ 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

@@ -1,36 +1,11 @@
-# @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"
+"platforms.linux-arm64" = { checksum = "sha256:a290581cfe4fe28ddd737dde3095f3dbeb7f2e4065cab4eae44dfc53b760c2f7", url = "https://dl.google.com/go/go1.26.1.linux-arm64.tar.gz"}
+"platforms.linux-x64" = { checksum = "sha256:031f088e5d955bab8657ede27ad4e3bc5b7c1ba281f05f245bcc304f327c987a", url = "https://dl.google.com/go/go1.26.1.linux-amd64.tar.gz"}
+"platforms.macos-arm64" = { checksum = "sha256:353df43a7811ce284c8938b5f3c7df40b7bfb6f56cb165b150bc40b5e2dd541f", url = "https://dl.google.com/go/go1.26.1.darwin-arm64.tar.gz"}
+"platforms.macos-x64" = { checksum = "sha256:65773dab2f8cc4cd23d93ba6d0a805de150ca0b78378879292be0b903b8cdd08", url = "https://dl.google.com/go/go1.26.1.darwin-amd64.tar.gz"}
+"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"
@@ -49,73 +24,19 @@ version = "0.9.2"
 backend = "go:mvdan.cc/gofumpt"
 
 [[tools.golangci-lint]]
-version = "2.11.4"
+version = "2.11.3"
 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"
+"platforms.linux-arm64" = { checksum = "sha256:ee3d95f301359e7d578e6d99c8ad5aeadbabc5a13009a30b2b0df11c8058afe9", url = "https://github.com/golangci/golangci-lint/releases/download/v2.11.3/golangci-lint-2.11.3-linux-arm64.tar.gz"}
+"platforms.linux-x64" = { checksum = "sha256:87bb8cddbcc825d5778b64e8a91b46c0526b247f4e2f2904dea74ec7450475d1", url = "https://github.com/golangci/golangci-lint/releases/download/v2.11.3/golangci-lint-2.11.3-linux-amd64.tar.gz"}
+"platforms.macos-arm64" = { checksum = "sha256:30ee39979c516b9d1adca289a3f93429d130c4c0fda5e57d637850894221f6cc", url = "https://github.com/golangci/golangci-lint/releases/download/v2.11.3/golangci-lint-2.11.3-darwin-arm64.tar.gz"}
+"platforms.macos-x64" = { checksum = "sha256:f93bda1f2cc981fd1326464020494be62f387bbf262706e1b3b644e5afacc440", url = "https://github.com/golangci/golangci-lint/releases/download/v2.11.3/golangci-lint-2.11.3-darwin-amd64.tar.gz"}
+"platforms.windows-x64" = { checksum = "sha256:cd42e890176bc5cfeb36225a77e66b9410ddd3a59a03551e23f6b210d29e1f67", url = "https://github.com/golangci/golangci-lint/releases/download/v2.11.3/golangci-lint-2.11.3-windows-amd64.zip"}
 
 [[tools.goreleaser]]
-version = "2.15.2"
+version = "2.14.3"
 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"
+"platforms.linux-arm64" = { checksum = "sha256:581a10e53c1176b3e81ee45cf531e02dbf899db0bc7b795669347df4276ce948", url = "https://github.com/goreleaser/goreleaser/releases/download/v2.14.3/goreleaser_Linux_arm64.tar.gz"}
+"platforms.linux-x64" = { checksum = "sha256:dc7faeeeb6da8bdfda788626263a4ae725892a8c7504b975c3234127d4a44579", url = "https://github.com/goreleaser/goreleaser/releases/download/v2.14.3/goreleaser_Linux_x86_64.tar.gz"}
+"platforms.macos-arm64" = { checksum = "sha256:3507798489e107a78aff36b169de48148a335ac26eb3161608d905f3f3a957bd", url = "https://github.com/goreleaser/goreleaser/releases/download/v2.14.3/goreleaser_Darwin_all.tar.gz"}
+"platforms.macos-x64" = { checksum = "sha256:3507798489e107a78aff36b169de48148a335ac26eb3161608d905f3f3a957bd", url = "https://github.com/goreleaser/goreleaser/releases/download/v2.14.3/goreleaser_Darwin_all.tar.gz"}
+"platforms.windows-x64" = { checksum = "sha256:3deea8ff471aa258a2d99f3e5302971d7028647ae8ddaf103257a8113e485a31", url = "https://github.com/goreleaser/goreleaser/releases/download/v2.14.3/goreleaser_Windows_x86_64.zip"}

mtglib/conns.go

@@ -3,12 +3,9 @@ package mtglib
 import (
 	"bytes"
 	"context"
-	"errors"
 	"fmt"
 	"io"
 	"net"
-	"sync/atomic"
-	"time"
 
 	"github.com/9seconds/mtg/v2/essentials"
 	"github.com/pires/go-proxyproto"
@@ -98,64 +95,3 @@ func newConnProxyProtocol(source, target essentials.Conn) *connProxyProtocol {
 		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

@@ -16,12 +16,6 @@ import (
 	"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
 
@@ -297,141 +291,6 @@ func (suite *ConnProxyProtocolTestSuite) TearDownTest() {
 	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{})
@@ -446,13 +305,3 @@ 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

@@ -77,13 +77,8 @@ const (
 	// DefaultIdleTimeout is a default timeout for closing a connection in case of
 	// idling.
 	//
-	// Set to 5 minutes to survive typical mobile sleep periods (2-5 min) and
-	// avoid racing with MTProto ping_delay_disconnect (~60s interval).
-	DefaultIdleTimeout = 5 * time.Minute
-
-	// DefaultHandshakeTimeout defines a time period during which the
-	// all handshake ceremonies must be completed.
-	DefaultHandshakeTimeout = 10 * time.Second
+	// Deprecated: no longer in use because of changed TCP relay algorithm.
+	DefaultIdleTimeout = time.Minute
 
 	// DefaultTolerateTimeSkewness is a default timeout for time skewness on a
 	// faketls timeout verification.

mtglib/internal/dc/init.go

@@ -2,10 +2,7 @@ package dc
 
 import (
 	"context"
-	"net"
 	"time"
-
-	"github.com/9seconds/mtg/v2/essentials"
 )
 
 type preferIP uint8
@@ -42,36 +39,46 @@ type Updater interface {
 }
 
 // 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
-})()
+var defaultDCAddrSet = dcAddrSet{
+	v4: map[int][]Addr{
+		1: {
+			{Network: "tcp4", Address: "149.154.175.50:443"},
+		},
+		2: {
+			{Network: "tcp4", Address: "149.154.167.51:443"},
+			{Network: "tcp4", Address: "95.161.76.100:443"},
+		},
+		3: {
+			{Network: "tcp4", Address: "149.154.175.100:443"},
+		},
+		4: {
+			{Network: "tcp4", Address: "149.154.167.91:443"},
+		},
+		5: {
+			{Network: "tcp4", Address: "149.154.171.5:443"},
+		},
+		203: {
+			{Network: "tcp4", Address: "91.105.192.100:443"},
+		},
+	},
+	v6: map[int][]Addr{
+		1: {
+			{Network: "tcp6", Address: "[2001:b28:f23d:f001::a]:443"},
+		},
+		2: {
+			{Network: "tcp6", Address: "[2001:67c:04e8:f002::a]:443"},
+		},
+		3: {
+			{Network: "tcp6", Address: "[2001:b28:f23d:f003::a]:443"},
+		},
+		4: {
+			{Network: "tcp6", Address: "[2001:67c:04e8:f004::a]:443"},
+		},
+		5: {
+			{Network: "tcp6", Address: "[2001:b28:f23f:f005::a]:443"},
+		},
+		203: {
+			{Network: "tcp6", Address: "[2a0a:f280:0203:000a:5000:0000:0000:0100]:443"},
+		},
+	},
+}

mtglib/internal/dc/telegram.go

@@ -20,7 +20,7 @@ func (t *Telegram) GetAddresses(dc int) []Addr {
 	case preferIPOnlyIPv4:
 		return t.view.getV4(dc)
 	case preferIPOnlyIPv6:
-		return t.view.getV6(dc)
+		return t.view.getV4(dc)
 	case preferIPPreferIPv4:
 		return append(t.view.getV4(dc), t.view.getV6(dc)...)
 	}

mtglib/internal/dc/view.go

@@ -5,19 +5,15 @@ type dcView struct {
 }
 
 func (d dcView) getV4(dc int) []Addr {
-	var addrs []Addr
-
+	addrs := d.publicConfigs.getV4(dc)
 	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 := d.publicConfigs.getV6(dc)
 	addrs = append(addrs, defaultDCAddrSet.getV6(dc)...)
-	addrs = append(addrs, d.publicConfigs.getV6(dc)...)
 
 	return addrs
 }

mtglib/internal/doppel/clock.go

@@ -0,0 +1,35 @@
+package doppel
+
+import (
+	"context"
+	"time"
+)
+
+type Clock struct {
+	stats *Stats
+	tick  chan struct{}
+}
+
+func (c Clock) Start(ctx context.Context) {
+	tickTock := time.NewTimer(c.stats.Delay())
+	defer func() {
+		tickTock.Stop()
+		select {
+		case <-tickTock.C:
+		default:
+		}
+	}()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-tickTock.C:
+			select {
+			case <-ctx.Done():
+			case c.tick <- struct{}{}:
+			}
+			tickTock.Reset(c.stats.Delay())
+		}
+	}
+}

mtglib/internal/doppel/clock_test.go

@@ -0,0 +1,80 @@
+package doppel
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/suite"
+)
+
+type ClockTestSuite struct {
+	suite.Suite
+
+	clock     Clock
+	wg        sync.WaitGroup
+	ctx       context.Context
+	ctxCancel context.CancelFunc
+}
+
+func (suite *ClockTestSuite) SetupTest() {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	suite.ctx = ctx
+	suite.ctxCancel = cancel
+	suite.clock = Clock{
+		stats: &Stats{
+			k:      StatsDefaultK,
+			lambda: StatsDefaultLambda,
+		},
+		tick: make(chan struct{}),
+	}
+
+	suite.wg.Go(func() {
+		suite.clock.Start(suite.ctx)
+	})
+}
+
+func (suite *ClockTestSuite) TearDownTest() {
+	suite.ctxCancel()
+	suite.wg.Wait()
+}
+
+func (suite *ClockTestSuite) TestTicks() {
+	received := 0
+
+	for range 3 {
+		select {
+		case <-suite.clock.tick:
+			received++
+		case <-time.After(2 * time.Second):
+			suite.Fail("timed out waiting for tick")
+		}
+	}
+
+	suite.Equal(3, received)
+}
+
+func (suite *ClockTestSuite) TestStopsOnCancel() {
+	select {
+	case <-suite.clock.tick:
+	case <-time.After(2 * time.Second):
+		suite.Fail("timed out waiting for first tick")
+	}
+
+	suite.ctxCancel()
+
+	time.Sleep(50 * time.Millisecond)
+
+	select {
+	case <-suite.clock.tick:
+		suite.Fail("received tick after cancel")
+	default:
+	}
+}
+
+func TestClock(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &ClockTestSuite{})
+}

mtglib/internal/doppel/conn.go

@@ -4,19 +4,11 @@ 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
 
@@ -24,92 +16,112 @@ type Conn struct {
 }
 
 type connPayload struct {
-	ctx         context.Context
-	ctxCancel   context.CancelCauseFunc
-	stats       Stats
-	wg          sync.WaitGroup
-	writeStream bytes.Buffer
-	writtenCond sync.Cond
-	done        bool
+	ctx           context.Context
+	ctxCancel     context.CancelCauseFunc
+	clock         Clock
+	wg            sync.WaitGroup
+	syncWriteLock sync.RWMutex
+	writeStream   bytes.Buffer
+	writeCond     *sync.Cond
 }
 
 func (c Conn) Write(p []byte) (int, error) {
-	if len(p) == 0 {
-		return 0, context.Cause(c.p.ctx)
-	}
+	c.p.syncWriteLock.RLock()
+	defer c.p.syncWriteLock.RUnlock()
 
-	c.p.writtenCond.L.Lock()
+	c.p.writeCond.L.Lock()
 	c.p.writeStream.Write(p)
-	c.p.writtenCond.L.Unlock()
-
-	c.p.writtenCond.Signal()
+	c.p.writeCond.L.Unlock()
 
 	return len(p), context.Cause(c.p.ctx)
 }
 
-func (c Conn) start() {
-	bp := doppelBufPool.Get().(*[]byte)
-	buf := *bp
-	defer doppelBufPool.Put(bp)
+func (c Conn) SyncWrite(p []byte) (int, error) {
+	c.p.syncWriteLock.Lock()
+	defer c.p.syncWriteLock.Unlock()
 
-	timer := time.NewTimer(c.p.stats.Delay())
-	defer timer.Stop()
+	c.p.writeCond.L.Lock()
+	// wait until buffer is exhausted
+	for c.p.writeStream.Len() != 0 && context.Cause(c.p.ctx) == nil {
+		c.p.writeCond.Wait()
+	}
+	c.p.writeStream.Write(p)
+	c.p.writeCond.L.Unlock()
+
+	if err := context.Cause(c.p.ctx); err != nil {
+		return len(p), err
+	}
+
+	c.p.writeCond.L.Lock()
+	// wait until data will be sent
+	for c.p.writeStream.Len() != 0 && context.Cause(c.p.ctx) == nil {
+		c.p.writeCond.Wait()
+	}
+	c.p.writeCond.L.Unlock()
+
+	return len(p), context.Cause(c.p.ctx)
+}
+
+func (c Conn) Start() {
+	c.p.wg.Go(func() {
+		c.start()
+	})
+}
+
+func (c Conn) start() {
+	defer c.p.writeCond.Broadcast()
+
+	buf := [tls.MaxRecordSize]byte{}
 
 	for {
 		select {
 		case <-c.p.ctx.Done():
 			return
-		case <-timer.C:
-			timer.Reset(c.p.stats.Delay())
+		case <-c.p.clock.tick:
 		}
 
-		size := c.p.stats.Size()
+		c.p.writeCond.L.Lock()
+		n, err := c.p.writeStream.Read(buf[:c.p.clock.stats.Size()])
+		c.p.writeCond.L.Unlock()
 
-		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 {
+		if n == 0 || err != nil {
 			continue
 		}
 
-		if err := tls.WriteRecordInPlace(c.Conn, buf, n); err != nil {
+		if err := tls.WriteRecord(c.Conn, buf[:n]); err != nil {
 			c.p.ctxCancel(err)
 			return
 		}
+
+		c.p.writeCond.Signal()
 	}
 }
 
 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 {
+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{},
+			writeCond: sync.NewCond(&sync.Mutex{}),
+			clock: Clock{
+				stats: stats,
+				tick:  make(chan struct{}),
 			},
 		},
 	}
 
 	rv.p.writeStream.Grow(tls.DefaultBufferSize)
 
+	rv.p.wg.Go(func() {
+		rv.p.clock.Start(ctx)
+	})
 	rv.p.wg.Go(func() {
 		rv.start()
 	})

mtglib/internal/doppel/conn_test.go

@@ -63,7 +63,7 @@ func (suite *ConnTestSuite) TearDownTest() {
 }
 
 func (suite *ConnTestSuite) makeConn() Conn {
-	return NewConn(suite.ctx, suite.connMock, Stats{
+	return NewConn(suite.ctx, suite.connMock, &Stats{
 		k:      2.0,
 		lambda: 0.01,
 	})
@@ -141,37 +141,6 @@ func (suite *ConnTestSuite) TestWriteReturnsErrorAfterStop() {
 	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")).
@@ -188,6 +157,136 @@ func (suite *ConnTestSuite) TestStopOnUnderlyingWriteError() {
 	}, 2*time.Second, time.Millisecond)
 }
 
+func (suite *ConnTestSuite) TestSyncWriteDataSent() {
+	suite.connMock.
+		On("Write", mock.AnythingOfType("[]uint8")).
+		Return(0, nil).
+		Maybe()
+
+	c := suite.makeConn()
+	defer c.Stop()
+
+	payload := []byte("sync hello")
+	n, err := c.SyncWrite(payload)
+	suite.NoError(err)
+	suite.Equal(len(payload), n)
+
+	// SyncWrite returns only after data is flushed to the wire.
+	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])
+
+		length := binary.BigEndian.Uint16(header[tls.SizeRecordType+tls.SizeVersion:])
+		rec := make([]byte, length)
+		_, err := io.ReadFull(reader, rec)
+		suite.NoError(err)
+
+		assembled.Write(rec)
+	}
+
+	suite.Equal(payload, assembled.Bytes())
+}
+
+func (suite *ConnTestSuite) TestSyncWriteDrainsBufferFirst() {
+	suite.connMock.
+		On("Write", mock.AnythingOfType("[]uint8")).
+		Return(0, nil).
+		Maybe()
+
+	c := suite.makeConn()
+	defer c.Stop()
+
+	// Buffer some data via async Write.
+	_, err := c.Write([]byte("first"))
+	suite.NoError(err)
+
+	// SyncWrite must drain "first" before sending "second".
+	n, err := c.SyncWrite([]byte("second"))
+	suite.NoError(err)
+	suite.Equal(6, n)
+
+	// All data should be on the wire now.
+	assembled := &bytes.Buffer{}
+	reader := bytes.NewReader(suite.connMock.Written())
+
+	for {
+		header := make([]byte, tls.SizeHeader)
+		if _, err := io.ReadFull(reader, header); err != nil {
+			break
+		}
+
+		length := binary.BigEndian.Uint16(header[tls.SizeRecordType+tls.SizeVersion:])
+		rec := make([]byte, length)
+		_, err := io.ReadFull(reader, rec)
+		suite.NoError(err)
+
+		assembled.Write(rec)
+	}
+
+	suite.Equal([]byte("firstsecond"), assembled.Bytes())
+}
+
+func (suite *ConnTestSuite) TestSyncWriteBlocksAsyncWrite() {
+	suite.connMock.
+		On("Write", mock.AnythingOfType("[]uint8")).
+		Return(0, nil).
+		Maybe()
+
+	c := suite.makeConn()
+	defer c.Stop()
+
+	// Start SyncWrite — it holds exclusive lock.
+	syncDone := make(chan struct{})
+
+	go func() {
+		defer close(syncDone)
+		c.SyncWrite([]byte("exclusive")) //nolint: errcheck
+	}()
+
+	// Give SyncWrite time to acquire the lock.
+	time.Sleep(10 * time.Millisecond)
+
+	// Async Write should block until SyncWrite completes.
+	writeDone := make(chan struct{})
+
+	go func() {
+		defer close(writeDone)
+		c.Write([]byte("blocked")) //nolint: errcheck
+	}()
+
+	// SyncWrite should finish first.
+	<-syncDone
+
+	select {
+	case <-writeDone:
+		// Write completed after SyncWrite — correct.
+	case <-time.After(2 * time.Second):
+		suite.Fail("async Write did not unblock after SyncWrite completed")
+	}
+}
+
+func (suite *ConnTestSuite) TestSyncWriteReturnsErrorAfterStop() {
+	suite.connMock.
+		On("Write", mock.AnythingOfType("[]uint8")).
+		Return(0, nil).
+		Maybe()
+
+	c := suite.makeConn()
+	c.Stop()
+
+	time.Sleep(10 * time.Millisecond)
+
+	_, err := c.SyncWrite([]byte("too late"))
+	suite.Error(err)
+}
+
 func TestConn(t *testing.T) {
 	t.Parallel()
 	suite.Run(t, &ConnTestSuite{})

mtglib/internal/doppel/ganger.go

@@ -2,9 +2,7 @@ package doppel
 
 import (
 	"context"
-	"fmt"
 	"sync"
-	"sync/atomic"
 	"time"
 
 	"github.com/9seconds/mtg/v2/essentials"
@@ -14,22 +12,8 @@ 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
@@ -47,11 +31,8 @@ type Ganger struct {
 
 	drs bool
 
-	stats     Stats
+	stats     *Stats
 	durations []time.Duration
-	certSizes []int
-
-	noiseParams atomic.Pointer[NoiseParams]
 
 	connRequests chan gangerConnRequest
 }
@@ -67,16 +48,6 @@ func (g *Ganger) 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{
@@ -110,10 +81,10 @@ func (g *Ganger) run() {
 		}
 	}()
 
-	scoutCollectedChan := make(chan scoutRaidResult)
+	scoutCollectedChan := make(chan []time.Duration)
 	currentScoutCollectedChan := scoutCollectedChan
 
-	updatedStatsChan := make(chan Stats)
+	updatedStatsChan := make(chan *Stats)
 
 	g.wg.Go(func() {
 		g.runScoutRaid(scoutCollectedChan)
@@ -123,29 +94,17 @@ func (g *Ganger) run() {
 		select {
 		case <-g.ctx.Done():
 			return
-		case result := <-currentScoutCollectedChan:
-			g.durations = append(g.durations, result.durations...)
+		case durations := <-currentScoutCollectedChan:
+			g.durations = append(g.durations, 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()
+				g.durations = g.durations[len(g.durations)-DoppelGangerMaxDurations:]
 			}
 
 			if len(g.durations) < MinDurationsToCalculate {
 				continue
 			}
 
-			durations := g.durations
 			currentScoutCollectedChan = nil
 			g.wg.Go(func() {
 				select {
@@ -169,45 +128,8 @@ func (g *Ganger) run() {
 	}
 }
 
-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
+func (g *Ganger) runScoutRaid(rvChan chan<- []time.Duration) {
+	durations := []time.Duration{}
 
 	for range g.scoutRaidRepeats {
 		learned, err := g.scout.Learn(g.ctx)
@@ -215,18 +137,13 @@ func (g *Ganger) runScoutRaid(rvChan chan<- scoutRaidResult) {
 			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)
-		}
+		durations = append(durations, learned...)
 	}
 
 	select {
 	case <-g.ctx.Done():
 		return
-	case rvChan <- result:
+	case rvChan <- durations:
 	}
 }
 
@@ -256,7 +173,7 @@ func NewGanger(
 		scoutRaidEach:    scoutEach,
 		scoutRaidRepeats: scoutRepeats,
 		drs:              drs,
-		stats: Stats{
+		stats: &Stats{
 			k:      StatsDefaultK,
 			lambda: StatsDefaultLambda,
 			drs:    drs,

mtglib/internal/doppel/scout.go

@@ -12,46 +12,36 @@ import (
 	"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
+func (s Scout) Learn(ctx context.Context) ([]time.Duration, error) {
+	var durations []time.Duration
 
 	for _, url := range s.urls {
 		learned, err := s.learn(ctx, url)
 		if err != nil {
-			return ScoutResult{}, err
+			return nil, err
 		}
 
-		combined.Durations = append(combined.Durations, learned.Durations...)
-
-		if learned.CertSize > 0 && combined.CertSize == 0 {
-			combined.CertSize = learned.CertSize
-		}
+		durations = append(durations, learned...)
 	}
 
-	return combined, nil
+	return durations, nil
 }
 
-func (s Scout) learn(ctx context.Context, url string) (ScoutResult, error) {
+func (s Scout) learn(ctx context.Context, url string) ([]time.Duration, error) {
 	client, results := s.makeClient()
 
 	if !strings.HasPrefix(url, "https://") {
-		return ScoutResult{}, fmt.Errorf("url %s must be https", url)
+		return nil, fmt.Errorf("url %s must be https", url)
 	}
 
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
-		return ScoutResult{}, err
+		return nil, err
 	}
 
 	resp, err := client.Do(req)
@@ -61,62 +51,31 @@ func (s Scout) learn(ctx context.Context, url string) (ScoutResult, error) {
 		client.CloseIdleConnections()
 	}
 
-	if err != nil {
-		return ScoutResult{}, err
+	if err != nil || len(results.data) == 0 {
+		return nil, err
 	}
 
-	data, writeIndex := results.Snapshot()
-
-	if len(data) == 0 {
-		return ScoutResult{}, nil
-	}
-
-	var result ScoutResult
-
-	// Compute inter-record durations (existing logic).
+	durations := []time.Duration{}
 	lastTimestamp := time.Time{}
 
-	for i, v := range data {
+	for i, v := range results.data {
 		if v.recordType != tls.TypeApplicationData {
 			continue
 		}
 
 		if lastTimestamp.IsZero() {
 			if i > 0 {
-				lastTimestamp = data[i-1].timestamp
+				lastTimestamp = results.data[i-1].timestamp
 			} else {
 				lastTimestamp = v.timestamp
 			}
 		}
 
-		result.Durations = append(result.Durations, v.timestamp.Sub(lastTimestamp))
+		durations = append(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
+	return durations, nil
 }
 
 func (s Scout) makeClient() (*http.Client, *ScoutConnCollected) {

mtglib/internal/doppel/scout_conn.go

@@ -14,10 +14,9 @@ type ScoutConn struct {
 
 	results *ScoutConnCollected
 	rawBuf  *bytes.Buffer
-	seenCCS bool
 }
 
-func (s *ScoutConn) Read(p []byte) (int, error) {
+func (s ScoutConn) Read(p []byte) (int, error) {
 	buf := &bytes.Buffer{}
 
 	for {
@@ -32,11 +31,7 @@ func (s *ScoutConn) Read(p []byte) (int, error) {
 			return 0, err
 		}
 
-		if recordType == tls.TypeChangeCipherSpec {
-			s.seenCCS = true
-		}
-
-		s.results.Add(recordType, int(length))
+		s.results.Add(recordType)
 		s.rawBuf.Write([]byte{recordType})
 		s.rawBuf.Write(tls.TLSVersion[:])
 
@@ -50,19 +45,11 @@ func (s *ScoutConn) Read(p []byte) (int, error) {
 	}
 }
 
-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 {
+func NewScoutConn(conn essentials.Conn, results *ScoutConnCollected) ScoutConn {
 	rawBuf := &bytes.Buffer{}
 	rawBuf.Grow(tls.MaxRecordSize)
 
-	return &ScoutConn{
+	return ScoutConn{
 		Conn:    tls.New(conn, false, false),
 		results: results,
 		rawBuf:  rawBuf,

mtglib/internal/doppel/scout_conn_collected.go

@@ -1,10 +1,6 @@
 package doppel
 
-import (
-	"slices"
-	"sync"
-	"time"
-)
+import "time"
 
 const (
 	ScoutConnCollectedPreallocSize = 100
@@ -13,47 +9,21 @@ const (
 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
+	data []ScoutConnResult
 }
 
-func (s *ScoutConnCollected) Add(record byte, payloadLen int) {
-	s.mu.Lock()
+func (s *ScoutConnCollected) Add(record byte) {
 	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,
+		data: make([]ScoutConnResult, 0, ScoutConnCollectedPreallocSize),
 	}
 }

mtglib/internal/doppel/scout_conn_collected_test.go

@@ -1,7 +1,6 @@
 package doppel
 
 import (
-	"sync"
 	"testing"
 	"time"
 
@@ -15,71 +14,28 @@ type ScoutConnCollectedTestSuite struct {
 
 func (suite *ScoutConnCollectedTestSuite) TestAddSingle() {
 	collected := NewScoutConnCollected()
-	collected.Add(tls.TypeApplicationData, 100)
+	collected.Add(tls.TypeApplicationData)
 
-	data, _ := collected.Snapshot()
-
-	suite.Len(data, 1)
-	suite.Equal(byte(tls.TypeApplicationData), data[0].recordType)
+	suite.Len(collected.data, 1)
+	suite.Equal(byte(tls.TypeApplicationData), collected.data[0].recordType)
 }
 
 func (suite *ScoutConnCollectedTestSuite) TestAddTimestampsAreMonotonic() {
 	collected := NewScoutConnCollected()
 
-	collected.Add(tls.TypeApplicationData, 100)
+	collected.Add(tls.TypeApplicationData)
 
 	time.Sleep(time.Microsecond)
-	collected.Add(tls.TypeApplicationData, 100)
+	collected.Add(tls.TypeApplicationData)
 
 	time.Sleep(time.Microsecond)
-	collected.Add(tls.TypeApplicationData, 100)
+	collected.Add(tls.TypeApplicationData)
 
-	data, _ := collected.Snapshot()
-
-	for i := 1; i < len(data); i++ {
-		suite.True(data[i].timestamp.After(data[i-1].timestamp))
+	for i := 1; i < len(collected.data); i++ {
+		suite.True(collected.data[i].timestamp.After(collected.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

@@ -22,9 +22,9 @@ func (suite *ScoutTestSuite) SetupSuite() {
 }
 
 func (suite *ScoutTestSuite) TestCollectResults() {
-	result, err := suite.scout.Learn(suite.ctx)
+	durations, err := suite.scout.Learn(suite.ctx)
 	suite.NoError(err)
-	suite.Less(3, len(result.Durations))
+	suite.Less(3, len(durations))
 }
 
 func (suite *ScoutTestSuite) TestCollectNothing() {

mtglib/internal/doppel/stats.go

@@ -112,7 +112,7 @@ func (d *Stats) Size() int {
 	return TLSRecordSizeMax
 }
 
-func NewStats(durations []time.Duration, drs bool) Stats {
+func NewStats(durations []time.Duration, drs bool) *Stats {
 	n := float64(len(durations))
 
 	// in milliseconds
@@ -162,7 +162,7 @@ func NewStats(durations []time.Duration, drs bool) Stats {
 	// λ = (Σxᵢᵏ / n)^(1/k)
 	lambda := math.Pow(sumXK/n, 1.0/k)
 
-	return Stats{
+	return &Stats{
 		k:      k,
 		lambda: lambda,
 		drs:    drs,

mtglib/internal/relay/pool_settings_constrained.go

@@ -1,13 +0,0 @@
-//go:build mips || mipsle
-
-package relay
-
-import "github.com/9seconds/mtg/v2/mtglib/internal/tls"
-
-const (
-	// MIPS is quite short in resources, and usually it means that it will run
-	// on Microtiks, OpenWRT-based routers or similar hardware. I think it worth
-	// to sacrifice a number of read syscalls (read, CPU load) to shrink
-	// limited RAM resources.
-	bufPoolSize = tls.MaxRecordPayloadSize / 2
-)

mtglib/internal/relay/pool_settings_other.go

@@ -1,9 +0,0 @@
-//go:build !mips && !mipsle
-
-package relay
-
-import "github.com/9seconds/mtg/v2/mtglib/internal/tls"
-
-const (
-	bufPoolSize = tls.MaxRecordPayloadSize
-)

mtglib/internal/relay/pools.go

@@ -1,18 +0,0 @@
-package relay
-
-import "sync"
-
-var bufPool = sync.Pool{
-	New: func() any {
-		b := make([]byte, bufPoolSize)
-		return &b
-	},
-}
-
-func acquireBuffer() *[]byte {
-	return bufPool.Get().(*[]byte)
-}
-
-func releaseBuffer(p *[]byte) {
-	bufPool.Put(p)
-}

mtglib/internal/relay/relay.go

@@ -6,6 +6,7 @@ import (
 	"io"
 
 	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
 )
 
 func Relay(ctx context.Context, log Logger, telegramConn, clientConn essentials.Conn) {
@@ -15,11 +16,11 @@ func Relay(ctx context.Context, log Logger, telegramConn, clientConn essentials.
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
-	stop := context.AfterFunc(ctx, func() {
+	go func() {
+		<-ctx.Done()
 		telegramConn.Close() //nolint: errcheck
 		clientConn.Close()   //nolint: errcheck
-	})
-	defer stop()
+	}()
 
 	closeChan := make(chan struct{})
 
@@ -35,13 +36,12 @@ func Relay(ctx context.Context, log Logger, telegramConn, clientConn essentials.
 }
 
 func pump(log Logger, src, dst essentials.Conn, direction string) {
-	buf := acquireBuffer()
-	defer releaseBuffer(buf)
+	var buf [tls.MaxRecordPayloadSize]byte
 
 	defer src.CloseRead()  //nolint: errcheck
 	defer dst.CloseWrite() //nolint: errcheck
 
-	n, err := io.CopyBuffer(src, dst, *buf)
+	n, err := io.CopyBuffer(src, dst, buf[:])
 
 	switch {
 	case err == nil:

mtglib/internal/tls/conn.go

@@ -34,6 +34,7 @@ type Conn struct {
 
 type connPayload struct {
 	readBuf      bytes.Buffer
+	writeBuf     bytes.Buffer
 	connBuffered *bufio.Reader
 	read         bool
 	write        bool
@@ -79,6 +80,7 @@ func New(conn essentials.Conn, read, write bool) Conn {
 	}
 
 	newConn.p.readBuf.Grow(DefaultBufferSize)
+	newConn.p.writeBuf.Grow(DefaultBufferSize)
 
 	return newConn
 }

mtglib/internal/tls/fake/client_side.go

@@ -6,12 +6,13 @@ import (
 	"crypto/sha256"
 	"crypto/subtle"
 	"encoding/binary"
-	"errors"
 	"fmt"
 	"io"
 	"net"
 	"slices"
 	"time"
+
+	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
 )
 
 const (
@@ -21,19 +22,12 @@ const (
 	// record_type(1) + version(2) + size(2) + handshake_type(1) + uint24_length(3) + client_version(2)
 	RandomOffset = 1 + 2 + 2 + 1 + 3 + 2
 
-	// https://datatracker.ietf.org/doc/html/rfc8701#name-grease-values
-	// https://medium.com/asecuritysite-when-bob-met-alice/in-cybersecurity-what-is-grease-9f8850558dea
-	GreaseMask      = 0x0f0f
-	GreaseValueType = 0x0a0a
-
 	sniDNSNamesListType = 0
 )
 
 var (
 	emptyRandom = [RandomLen]byte{}
 	extTypeSNI  = [2]byte{}
-
-	ErrCannotFindCipher = errors.New("cannot find a cipher")
 )
 
 type ClientHello struct {
@@ -48,6 +42,11 @@ func ReadClientHello(
 	hostname string,
 	tolerateTimeSkewness time.Duration,
 ) (*ClientHello, error) {
+	if err := conn.SetReadDeadline(time.Now().Add(ClientHelloReadTimeout)); err != nil {
+		return nil, fmt.Errorf("cannot set read deadline: %w", err)
+	}
+	defer conn.SetReadDeadline(resetDeadline) //nolint: errcheck
+
 	// This is how FakeTLS is organized:
 	//  1. We create sha256 HMAC with a given secret
 	//  2. We dump there a whole TLS frame except of the fact that random
@@ -57,17 +56,25 @@ func ReadClientHello(
 	//  4. New digest should be all 0 except of last 4 bytes
 	//  5. Last 4 bytes are little endian uint32 of UNIX timestamp when
 	//     this message was created.
-	clientHelloCopy, handshakeReader, err := parseClientHello(conn)
+	handshakeCopyBuf := &bytes.Buffer{}
+	reader := io.TeeReader(conn, handshakeCopyBuf)
+
+	reader, err := parseTLSHeader(reader)
 	if err != nil {
-		return nil, fmt.Errorf("cannot read client hello: %w", err)
+		return nil, fmt.Errorf("cannot parse tls header: %w", err)
 	}
 
-	hello, err := parseHandshake(handshakeReader)
+	reader, err = parseHandshakeHeader(reader)
+	if err != nil {
+		return nil, fmt.Errorf("cannot parse handshake header: %w", err)
+	}
+
+	hello, err := parseHandshake(reader)
 	if err != nil {
 		return nil, fmt.Errorf("cannot parse handshake: %w", err)
 	}
 
-	sniHostnames, err := parseSNI(handshakeReader)
+	sniHostnames, err := parseSNI(reader)
 	if err != nil {
 		return nil, fmt.Errorf("cannot parse SNI: %w", err)
 	}
@@ -78,10 +85,10 @@ func ReadClientHello(
 
 	digest := hmac.New(sha256.New, secret)
 	// we write a copy of the handshake with client random all nullified.
-	digest.Write(clientHelloCopy.Next(RandomOffset))
-	clientHelloCopy.Next(RandomLen)
+	digest.Write(handshakeCopyBuf.Next(RandomOffset))
+	handshakeCopyBuf.Next(RandomLen)
 	digest.Write(emptyRandom[:])
-	digest.Write(clientHelloCopy.Bytes())
+	digest.Write(handshakeCopyBuf.Bytes())
 
 	computed := digest.Sum(nil)
 
@@ -103,6 +110,58 @@ func ReadClientHello(
 	return hello, nil
 }
 
+func parseTLSHeader(r io.Reader) (io.Reader, error) {
+	// record_type(1) + version(2) + size(2)
+	//   16 - type is 0x16 (handshake record)
+	//   03 01 - protocol version is "3,1" (also known as TLS 1.0)
+	//   00 f8 - 0xF8 (248) bytes of handshake message follows
+	header := [1 + 2 + 2]byte{}
+
+	if _, err := io.ReadFull(r, header[:]); err != nil {
+		return nil, fmt.Errorf("cannot read record header: %w", err)
+	}
+
+	if header[0] != tls.TypeHandshake {
+		return nil, fmt.Errorf("unexpected record type %#x", header[0])
+	}
+
+	if header[1] != 3 || header[2] != 1 {
+		return nil, fmt.Errorf("unexpected protocol version %#x %#x", header[1], header[2])
+	}
+
+	length := int64(binary.BigEndian.Uint16(header[3:]))
+	buf := &bytes.Buffer{}
+
+	_, err := io.CopyN(buf, r, length)
+
+	return buf, err
+}
+
+func parseHandshakeHeader(r io.Reader) (io.Reader, error) {
+	// type(1) + size(3 / uint24)
+	// 01 - handshake message type 0x01 (client hello)
+	// 00 00 f4 - 0xF4 (244) bytes of client hello data follows
+	header := [1 + 3]byte{}
+
+	if _, err := io.ReadFull(r, header[:]); err != nil {
+		return nil, fmt.Errorf("cannot read handshake header: %w", err)
+	}
+
+	if header[0] != TypeHandshakeClient {
+		return nil, fmt.Errorf("incorrect handshake type: %#x", header[0])
+	}
+
+	// unfortunately there is not uint24 in golang, so we just reust header
+	header[0] = 0
+
+	length := int64(binary.BigEndian.Uint32(header[:]))
+	buf := &bytes.Buffer{}
+
+	_, err := io.CopyN(buf, r, length)
+
+	return buf, err
+}
+
 func parseHandshake(r io.Reader) (*ClientHello, error) {
 	//  A protocol version of "3,3" (meaning TLS 1.2) is given.
 	header := [2]byte{}
@@ -133,27 +192,16 @@ func parseHandshake(r io.Reader) (*ClientHello, error) {
 
 	cipherSuiteLen := int64(binary.BigEndian.Uint16(header[:]))
 
-	// Pick the first non-GREASE cipher suite from the list.
-	// Real TLS servers never select GREASE values (RFC 8701, pattern 0x?a?a),
-	// so echoing them back is a trivial DPI fingerprint.
-	// cipherSuiteLen is in bytes; each cipher suite is 2 bytes.
-	for range cipherSuiteLen / 2 {
-		if _, err := io.ReadFull(r, header[:]); err != nil {
-			return nil, fmt.Errorf("cannot read cipher suite: %w", err)
-		}
-
-		if hello.CipherSuite != 0 {
-			// do not forget we have to scan until the end
-			continue
-		}
-
-		if cs := binary.BigEndian.Uint16(header[:]); cs&GreaseMask != GreaseValueType {
-			hello.CipherSuite = cs
-		}
+	// we do not care about picking up any cipher. we pick the first one,
+	// so it is always should be present.
+	if _, err := io.ReadFull(r, header[:]); err != nil {
+		return nil, fmt.Errorf("cannot read first cipher suite: %w", err)
 	}
 
-	if hello.CipherSuite == 0 {
-		return nil, ErrCannotFindCipher
+	hello.CipherSuite = binary.BigEndian.Uint16(header[:])
+
+	if _, err := io.CopyN(io.Discard, r, cipherSuiteLen-2); err != nil {
+		return nil, fmt.Errorf("cannot skip remaining cipher suites: %w", err)
 	}
 
 	if _, err := io.ReadFull(r, header[:1]); err != nil {

mtglib/internal/tls/fake/client_side_snapshot_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/9seconds/mtg/v2/mtglib"
 	"github.com/9seconds/mtg/v2/mtglib/internal/tls/fake"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 )
@@ -70,6 +71,11 @@ func (suite *ParseClientHelloSnapshotTestSuite) makeConn(data []byte) *parseClie
 		readBuf: readBuf,
 	}
 
+	connMock.
+		On("SetReadDeadline", mock.AnythingOfType("time.Time")).
+		Twice().
+		Return(nil)
+
 	return connMock
 }
 

mtglib/internal/tls/fake/client_side_test.go

@@ -2,11 +2,9 @@ package fake_test
 
 import (
 	"bytes"
-	cryptotls "crypto/tls"
 	"encoding/binary"
-	"encoding/json"
+	"errors"
 	"io"
-	"os"
 	"testing"
 	"time"
 
@@ -14,6 +12,7 @@ import (
 	"github.com/9seconds/mtg/v2/mtglib"
 	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
 	"github.com/9seconds/mtg/v2/mtglib/internal/tls/fake"
+	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 )
@@ -52,6 +51,11 @@ func (suite *ParseClientHelloTestSuite) SetupTest() {
 	suite.connMock = &parseClientHelloConnMock{
 		readBuf: suite.readBuf,
 	}
+
+	suite.connMock.
+		On("SetReadDeadline", mock.AnythingOfType("time.Time")).
+		Twice().
+		Return(nil)
 }
 
 func (suite *ParseClientHelloTestSuite) TearDownTest() {
@@ -63,11 +67,23 @@ type ParseClientHello_TLSHeaderTestSuite struct {
 }
 
 func (suite *ParseClientHello_TLSHeaderTestSuite) TestEmpty() {
+	suite.connMock.ExpectedCalls = []*mock.Call{}
+	suite.connMock.
+		On("SetReadDeadline", mock.AnythingOfType("time.Time")).
+		Once().
+		Return(errors.New("fail"))
+
 	_, err := fake.ReadClientHello(suite.connMock, suite.secret.Key[:], suite.secret.Host, TolerateTime)
-	suite.ErrorContains(err, "cannot read client hello")
+	suite.ErrorContains(err, "fail")
 }
 
 func (suite *ParseClientHello_TLSHeaderTestSuite) TestNothing() {
+	suite.connMock.ExpectedCalls = []*mock.Call{}
+	suite.connMock.
+		On("SetReadDeadline", mock.AnythingOfType("time.Time")).
+		Twice().
+		Return(nil)
+
 	_, err := fake.ReadClientHello(suite.connMock, suite.secret.Key[:], suite.secret.Host, TolerateTime)
 	suite.ErrorIs(err, io.EOF)
 }
@@ -216,13 +232,12 @@ func (suite *ParseClientHelloHandshakeBodyTestSuite) TestCannotReadCipherSuiteLe
 }
 
 func (suite *ParseClientHelloHandshakeBodyTestSuite) TestCannotReadFirstCipherSuite() {
-	body := make([]byte, 2+fake.RandomLen+1+2+1) // cipherSuiteLen=2 but only 1 byte available
-	binary.BigEndian.PutUint16(body[2+fake.RandomLen+1:], 2)
+	body := make([]byte, 2+fake.RandomLen+1+2)
 
 	suite.writeBody(body)
 
 	_, err := fake.ReadClientHello(suite.connMock, suite.secret.Key[:], suite.secret.Host, TolerateTime)
-	suite.ErrorContains(err, "cannot read cipher suite")
+	suite.ErrorContains(err, "cannot read first cipher suite")
 }
 
 func (suite *ParseClientHelloHandshakeBodyTestSuite) TestCannotSkipRemainingCipherSuites() {
@@ -232,27 +247,12 @@ func (suite *ParseClientHelloHandshakeBodyTestSuite) TestCannotSkipRemainingCiph
 	suite.writeBody(body)
 
 	_, err := fake.ReadClientHello(suite.connMock, suite.secret.Key[:], suite.secret.Host, TolerateTime)
-	suite.ErrorContains(err, "cannot read cipher suite")
-}
-
-func (suite *ParseClientHelloHandshakeBodyTestSuite) TestCannotFindCipher() {
-	// All cipher suites are GREASE values — must return ErrCannotFindCipher.
-	body := make([]byte, 2+fake.RandomLen+1+2+4+1)
-	binary.BigEndian.PutUint16(body[2+fake.RandomLen+1:], 4)
-	binary.BigEndian.PutUint16(body[2+fake.RandomLen+1+2:], 0x0a0a)
-	binary.BigEndian.PutUint16(body[2+fake.RandomLen+1+2+2:], 0x1a1a)
-	body[2+fake.RandomLen+1+2+4] = 1
-
-	suite.writeBody(body)
-
-	_, err := fake.ReadClientHello(suite.connMock, suite.secret.Key[:], suite.secret.Host, TolerateTime)
-	suite.ErrorIs(err, fake.ErrCannotFindCipher)
+	suite.ErrorContains(err, "cannot skip remaining cipher suites")
 }
 
 func (suite *ParseClientHelloHandshakeBodyTestSuite) TestCannotReadCompressionMethodsLength() {
 	body := make([]byte, 2+fake.RandomLen+1+2+2)
 	binary.BigEndian.PutUint16(body[2+fake.RandomLen+1:], 2)
-	binary.BigEndian.PutUint16(body[2+fake.RandomLen+1+2:], cryptotls.TLS_AES_128_GCM_SHA256)
 
 	suite.writeBody(body)
 
@@ -263,7 +263,6 @@ func (suite *ParseClientHelloHandshakeBodyTestSuite) TestCannotReadCompressionMe
 func (suite *ParseClientHelloHandshakeBodyTestSuite) TestCannotSkipCompressionMethods() {
 	body := make([]byte, 2+fake.RandomLen+1+2+2+1)
 	binary.BigEndian.PutUint16(body[2+fake.RandomLen+1:], 2)
-	binary.BigEndian.PutUint16(body[2+fake.RandomLen+1+2:], cryptotls.TLS_AES_128_GCM_SHA256)
 	body[2+fake.RandomLen+1+2+2] = 1
 
 	suite.writeBody(body)
@@ -299,7 +298,6 @@ func (suite *ParseClientHelloSNITestSuite) writeExtensions(extensions []byte) {
 	// cipherSuite(2) + compressionLen(1) + compression(1) = 41
 	body := make([]byte, 41)
 	binary.BigEndian.PutUint16(body[35:], 2)
-	binary.BigEndian.PutUint16(body[37:], cryptotls.TLS_AES_128_GCM_SHA256)
 	body[39] = 1
 
 	suite.readBuf.Write(body)
@@ -395,268 +393,3 @@ func TestParseClientHelloSNI(t *testing.T) {
 	t.Parallel()
 	suite.Run(t, &ParseClientHelloSNITestSuite{})
 }
-
-// fragmentTLSRecord splits a single TLS record into n TLS records by
-// dividing the payload into roughly equal parts. Each part gets its own
-// TLS record header with the same record type and version.
-func fragmentTLSRecord(t testing.TB, full []byte, n int) []byte {
-	t.Helper()
-
-	recordType := full[0]
-	version := full[1:3]
-	payload := full[tls.SizeHeader:]
-
-	chunkSize := len(payload) / n
-	result := &bytes.Buffer{}
-
-	for i := 0; i < n; i++ {
-		start := i * chunkSize
-		end := start + chunkSize
-
-		if i == n-1 {
-			end = len(payload)
-		}
-
-		chunk := payload[start:end]
-		result.WriteByte(recordType)
-		result.Write(version)
-		require.NoError(t, binary.Write(result, binary.BigEndian, uint16(len(chunk))))
-		result.Write(chunk)
-	}
-
-	return result.Bytes()
-}
-
-// splitPayloadAt creates two TLS records from a single record by splitting
-// the payload at the given byte position.
-func splitPayloadAt(t testing.TB, full []byte, pos int) []byte {
-	t.Helper()
-
-	payload := full[tls.SizeHeader:]
-	buf := &bytes.Buffer{}
-
-	buf.WriteByte(tls.TypeHandshake)
-	buf.Write(full[1:3])
-	require.NoError(t, binary.Write(buf, binary.BigEndian, uint16(pos)))
-	buf.Write(payload[:pos])
-
-	buf.WriteByte(tls.TypeHandshake)
-	buf.Write(full[1:3])
-	require.NoError(t, binary.Write(buf, binary.BigEndian, uint16(len(payload)-pos)))
-	buf.Write(payload[pos:])
-
-	return buf.Bytes()
-}
-
-type ParseClientHelloFragmentedTestSuite struct {
-	suite.Suite
-
-	secret   mtglib.Secret
-	snapshot *clientHelloSnapshot
-}
-
-func (s *ParseClientHelloFragmentedTestSuite) SetupSuite() {
-	parsed, err := mtglib.ParseSecret(
-		"ee367a189aee18fa31c190054efd4a8e9573746f726167652e676f6f676c65617069732e636f6d",
-	)
-	require.NoError(s.T(), err)
-
-	s.secret = parsed
-
-	fileData, err := os.ReadFile("testdata/client-hello-ok-19dfe38384b9884b.json")
-	require.NoError(s.T(), err)
-
-	s.snapshot = &clientHelloSnapshot{}
-	require.NoError(s.T(), json.Unmarshal(fileData, s.snapshot))
-}
-
-func (s *ParseClientHelloFragmentedTestSuite) makeConn(data []byte) *parseClientHelloConnMock {
-	readBuf := &bytes.Buffer{}
-	readBuf.Write(data)
-
-	connMock := &parseClientHelloConnMock{
-		readBuf: readBuf,
-	}
-
-	return connMock
-}
-
-func (s *ParseClientHelloFragmentedTestSuite) TestReassemblySuccess() {
-	full := s.snapshot.GetFull()
-
-	tests := []struct {
-		name string
-		data []byte
-	}{
-		{"two equal fragments", fragmentTLSRecord(s.T(), full, 2)},
-		{"three equal fragments", fragmentTLSRecord(s.T(), full, 3)},
-		{"single byte first fragment", splitPayloadAt(s.T(), full, 1)},
-		{"three byte first fragment", splitPayloadAt(s.T(), full, 3)},
-	}
-
-	for _, tt := range tests {
-		s.Run(tt.name, func() {
-			connMock := s.makeConn(tt.data)
-			defer connMock.AssertExpectations(s.T())
-
-			hello, err := fake.ReadClientHello(
-				connMock,
-				s.secret.Key[:],
-				s.secret.Host,
-				TolerateTime,
-			)
-			s.Require().NoError(err)
-
-			s.Equal(s.snapshot.GetRandom(), hello.Random[:])
-			s.Equal(s.snapshot.GetSessionID(), hello.SessionID)
-			s.Equal(uint16(s.snapshot.CipherSuite), hello.CipherSuite)
-		})
-	}
-}
-
-func (s *ParseClientHelloFragmentedTestSuite) TestReassemblyErrors() {
-	full := s.snapshot.GetFull()
-	payload := full[tls.SizeHeader:]
-
-	tests := []struct {
-		name      string
-		buildData func() []byte
-		errMsg    string
-	}{
-		{
-			name: "wrong continuation record type",
-			buildData: func() []byte {
-				buf := &bytes.Buffer{}
-				buf.WriteByte(tls.TypeHandshake)
-				buf.Write(full[1:3])
-				require.NoError(s.T(), binary.Write(buf, binary.BigEndian, uint16(10)))
-				buf.Write(payload[:10])
-				// Wrong type: application data instead of handshake
-				buf.WriteByte(tls.TypeApplicationData)
-				buf.Write(full[1:3])
-				require.NoError(s.T(), binary.Write(buf, binary.BigEndian, uint16(len(payload)-10)))
-				buf.Write(payload[10:])
-				return buf.Bytes()
-			},
-			errMsg: "unexpected record type",
-		},
-		{
-			name: "too many continuation records",
-			buildData: func() []byte {
-				// Handshake header claiming 256 bytes, but we only send 1 byte per continuation
-				handshakePayload := []byte{0x01, 0x00, 0x01, 0x00}
-				buf := &bytes.Buffer{}
-				buf.WriteByte(tls.TypeHandshake)
-				buf.Write([]byte{3, 1})
-				require.NoError(s.T(), binary.Write(buf, binary.BigEndian, uint16(len(handshakePayload))))
-				buf.Write(handshakePayload)
-				for range 11 {
-					buf.WriteByte(tls.TypeHandshake)
-					buf.Write([]byte{3, 1})
-					require.NoError(s.T(), binary.Write(buf, binary.BigEndian, uint16(1)))
-					buf.WriteByte(0xAB)
-				}
-				return buf.Bytes()
-			},
-			errMsg: "too many fragments",
-		},
-		{
-			name: "zero-length continuation record",
-			buildData: func() []byte {
-				buf := &bytes.Buffer{}
-				buf.WriteByte(tls.TypeHandshake)
-				buf.Write(full[1:3])
-				require.NoError(s.T(), binary.Write(buf, binary.BigEndian, uint16(10)))
-				buf.Write(payload[:10])
-				// Valid header but zero-length payload
-				buf.WriteByte(tls.TypeHandshake)
-				buf.Write(full[1:3])
-				require.NoError(s.T(), binary.Write(buf, binary.BigEndian, uint16(0)))
-				return buf.Bytes()
-			},
-			errMsg: "cannot read record header",
-		},
-		{
-			name: "wrong continuation record version",
-			buildData: func() []byte {
-				buf := &bytes.Buffer{}
-				buf.WriteByte(tls.TypeHandshake)
-				buf.Write(full[1:3])
-				require.NoError(s.T(), binary.Write(buf, binary.BigEndian, uint16(10)))
-				buf.Write(payload[:10])
-				// Wrong version: 3.3 instead of 3.1
-				buf.WriteByte(tls.TypeHandshake)
-				buf.Write([]byte{3, 3})
-				require.NoError(s.T(), binary.Write(buf, binary.BigEndian, uint16(len(payload)-10)))
-				buf.Write(payload[10:])
-				return buf.Bytes()
-			},
-			errMsg: "unexpected protocol version",
-		},
-		{
-			name: "handshake message too large",
-			buildData: func() []byte {
-				// Handshake header claiming 0x010000 (65536) bytes — exceeds 0xFFFF limit
-				handshakePayload := []byte{0x01, 0x01, 0x00, 0x00}
-				buf := &bytes.Buffer{}
-				buf.WriteByte(tls.TypeHandshake)
-				buf.Write([]byte{3, 1})
-				require.NoError(s.T(), binary.Write(buf, binary.BigEndian, uint16(len(handshakePayload))))
-				buf.Write(handshakePayload)
-				return buf.Bytes()
-			},
-			errMsg: "cannot read record header",
-		},
-		{
-			name: "truncated continuation record header",
-			buildData: func() []byte {
-				buf := &bytes.Buffer{}
-				buf.WriteByte(tls.TypeHandshake)
-				buf.Write(full[1:3])
-				require.NoError(s.T(), binary.Write(buf, binary.BigEndian, uint16(10)))
-				buf.Write(payload[:10])
-				// Connection ends mid-header (only 2 bytes)
-				buf.WriteByte(tls.TypeHandshake)
-				buf.WriteByte(3)
-				return buf.Bytes()
-			},
-			errMsg: "cannot read record header",
-		},
-		{
-			name: "truncated continuation record payload",
-			buildData: func() []byte {
-				buf := &bytes.Buffer{}
-				buf.WriteByte(tls.TypeHandshake)
-				buf.Write(full[1:3])
-				require.NoError(s.T(), binary.Write(buf, binary.BigEndian, uint16(10)))
-				buf.Write(payload[:10])
-				// Claims 100 bytes but no payload follows
-				buf.WriteByte(tls.TypeHandshake)
-				buf.Write(full[1:3])
-				require.NoError(s.T(), binary.Write(buf, binary.BigEndian, uint16(100)))
-				return buf.Bytes()
-			},
-			errMsg: "EOF",
-		},
-	}
-
-	for _, tt := range tests {
-		s.Run(tt.name, func() {
-			connMock := s.makeConn(tt.buildData())
-			defer connMock.AssertExpectations(s.T())
-
-			_, err := fake.ReadClientHello(
-				connMock,
-				s.secret.Key[:],
-				s.secret.Host,
-				TolerateTime,
-			)
-			s.ErrorContains(err, tt.errMsg)
-		})
-	}
-}
-
-func TestParseClientHelloFragmented(t *testing.T) {
-	t.Parallel()
-	suite.Run(t, &ParseClientHelloFragmentedTestSuite{})
-}

mtglib/internal/tls/fake/init.go

@@ -2,6 +2,15 @@ package fake
 
 import (
 	"errors"
+	"time"
 )
 
-var ErrBadDigest = errors.New("incorrect client random")
+const (
+	ClientHelloReadTimeout = 5 * time.Second
+)
+
+var (
+	resetDeadline time.Time
+
+	ErrBadDigest = errors.New("incorrect client random")
+)

mtglib/internal/tls/fake/server_side.go

@@ -13,14 +13,6 @@ import (
 	"golang.org/x/crypto/curve25519"
 )
 
-// NoiseParams controls the size of the fake ApplicationData record
-// in ServerHello. If Mean is 0, the legacy random range (2500-4700)
-// is used.
-type NoiseParams struct {
-	Mean   int
-	Jitter int
-}
-
 const (
 	TypeHandshakeServer = 0x02
 	ChangeCipherValue   = 0x01
@@ -40,13 +32,13 @@ var serverHelloSuffix = []byte{
 	0x00, 0x20, // 32 bytes of key
 }
 
-func SendServerHello(w io.Writer, secret []byte, clientHello *ClientHello, noise NoiseParams) error {
+func SendServerHello(w io.Writer, secret []byte, clientHello *ClientHello) error {
 	buf := &bytes.Buffer{}
 	buf.Grow(tls.MaxRecordSize)
 
 	generateServerHello(buf, clientHello)
 	generateChangeCipherValue(buf)
-	generateNoise(buf, noise)
+	generateNoise(buf)
 
 	packet := buf.Bytes()
 	digest := hmac.New(sha256.New, secret)
@@ -132,31 +124,12 @@ func generateChangeCipherValue(buf *bytes.Buffer) {
 	buf.WriteByte(ChangeCipherValue)
 }
 
-// generateNoise writes a single ApplicationData record mimicking the combined
-// size of a real TLS 1.3 encrypted server handshake (EncryptedExtensions +
-// Certificate chain + CertificateVerify + Finished).
-//
-// NOTE: Must be exactly ONE ApplicationData record — the Telegram client reads
-// ServerHello + CCS + 1 ApplicationData and computes HMAC over all three.
-// Multiple records would cause HMAC mismatch and connection failure.
-func generateNoise(buf *bytes.Buffer, noise NoiseParams) {
-	var size int
+func generateNoise(buf *bytes.Buffer) {
+	data := make([]byte, int64(1024+rnd.IntN(3092)))
 
-	if noise.Mean > 0 && noise.Jitter > 0 {
-		// Calibrated: use measured cert chain size ± jitter.
-		size = noise.Mean - noise.Jitter + rnd.IntN(2*noise.Jitter)
-		if size < 1000 {
-			size = 1000
-		}
-	} else {
-		// Legacy fallback: random in 2500-4700 range.
-		size = 2500 + rnd.IntN(2200)
-	}
-
-	data := make([]byte, size)
-	if _, err := rand.Read(data); err != nil {
+	if _, err := rand.Read(data[:]); err != nil {
 		panic(err)
 	}
 
-	tls.WriteRecord(buf, data) //nolint: errcheck
+	tls.WriteRecord(buf, data[:]) //nolint: errcheck
 }

mtglib/internal/tls/fake/server_side_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/9seconds/mtg/v2/mtglib/internal/doppel"
 	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
 	"github.com/9seconds/mtg/v2/mtglib/internal/tls/fake"
 	"github.com/stretchr/testify/suite"
@@ -38,7 +39,7 @@ func (suite *SendServerHelloTestSuite) SetupTest() {
 }
 
 func (suite *SendServerHelloTestSuite) TestRecordStructure() {
-	err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello, fake.NoiseParams{})
+	err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello)
 	suite.NoError(err)
 
 	var rec bytes.Buffer
@@ -58,13 +59,13 @@ func (suite *SendServerHelloTestSuite) TestRecordStructure() {
 	recordType, length, err := tls.ReadRecord(suite.buf, &rec)
 	suite.NoError(err)
 	suite.Equal(byte(tls.TypeApplicationData), recordType)
-	suite.GreaterOrEqual(length, int64(2500))
+	suite.Greater(length, int64(doppel.TLSRecordSizeStart))
 
 	suite.Empty(suite.buf.Bytes())
 }
 
 func (suite *SendServerHelloTestSuite) TestHMAC() {
-	err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello, fake.NoiseParams{})
+	err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello)
 	suite.NoError(err)
 
 	packet := make([]byte, suite.buf.Len())
@@ -82,7 +83,7 @@ func (suite *SendServerHelloTestSuite) TestHMAC() {
 }
 
 func (suite *SendServerHelloTestSuite) TestHandshakePayload() {
-	err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello, fake.NoiseParams{})
+	err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello)
 	suite.NoError(err)
 
 	packet := suite.buf.Bytes()
@@ -104,7 +105,7 @@ func (suite *SendServerHelloTestSuite) TestHandshakePayload() {
 }
 
 func (suite *SendServerHelloTestSuite) TestChangeCipherSpec() {
-	err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello, fake.NoiseParams{})
+	err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello)
 	suite.NoError(err)
 
 	// Skip first record
@@ -123,33 +124,6 @@ func (suite *SendServerHelloTestSuite) TestChangeCipherSpec() {
 	suite.Equal([]byte{fake.ChangeCipherValue}, rec.Bytes())
 }
 
-func (suite *SendServerHelloTestSuite) TestCalibratedNoiseSize() {
-	noise := fake.NoiseParams{Mean: 6480, Jitter: 100}
-	err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello, noise)
-	suite.NoError(err)
-
-	var rec bytes.Buffer
-
-	// Skip ServerHello
-	_, _, err = tls.ReadRecord(suite.buf, &rec)
-	suite.NoError(err)
-
-	// Skip ChangeCipherSpec
-	rec.Reset()
-	_, _, err = tls.ReadRecord(suite.buf, &rec)
-	suite.NoError(err)
-
-	// Read noise ApplicationData
-	rec.Reset()
-	recordType, length, err := tls.ReadRecord(suite.buf, &rec)
-	suite.NoError(err)
-	suite.Equal(byte(tls.TypeApplicationData), recordType)
-
-	// Should be within mean ± jitter range.
-	suite.GreaterOrEqual(length, int64(noise.Mean-noise.Jitter))
-	suite.LessOrEqual(length, int64(noise.Mean+noise.Jitter))
-}
-
 func TestSendServerHello(t *testing.T) {
 	t.Parallel()
 	suite.Run(t, &SendServerHelloTestSuite{})

mtglib/internal/tls/fake/testdata/client-hello-ok-grease-first.json

@@ -1,8 +0,0 @@
-{
-  "time": 1617181365,
-  "random": "w4TaDfYg/aUKdx1oi68vxMKvHJczRNvtRRppLETzeNE=",
-  "sessionId": "St2BZ2uHMFn3B2trD1jfdtpjoJOOg6JBeLhFcyCMCq4=",
-  "host": "storage.googleapis.com",
-  "cipherSuite": 4867,
-  "full": "FgMBAgIBAAH+AwPDhNoN9iD9pQp3HWiLry/Ewq8clzNE2+1FGmksRPN40SBK3YFna4cwWfcHa2sPWN922mOgk46DokF4uEVzIIwKrgA2WloTAxMBEwLALMArwCTAI8AKwAnMqcAwwC/AKMAnwBTAE8yoAJ0AnAA9ADwANQAvwAjAEgAKAQABf/8BAAEAAAAAGwAZAAAWc3RvcmFnZS5nb29nbGVhcGlzLmNvbQAXAAAADQAYABYEAwgEBAEFAwIDCAUIBQUBCAYGAQIBAAUABQEAAAAAM3QAAAASAAAAEAAwAC4CaDIFaDItMTYFaDItMTUFaDItMTQIc3BkeS8zLjEGc3BkeS8zCGh0dHAvMS4xAAsAAgEAADMAJgAkAB0AIAf+6C8fSRJSAC7CyUvdR9kDclNR9KLCsCFHpVZ3bC8iAC0AAgEBACsACQgDBAMDAwIDAQAKAAoACAAdABcAGAAZABUAoQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
-}

mtglib/internal/tls/fake/utils.go

@@ -1,158 +0,0 @@
-package fake
-
-import (
-	"bytes"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
-)
-
-const (
-	maxFragmentsCount = 10
-)
-
-var ErrTooManyFragments = errors.New("too many fragments")
-
-// https://datatracker.ietf.org/doc/html/rfc5246#section-6.2.1
-// client hello can be fragmented in a series of packets:
-//
-//	Bytes on the wire:
-//
-// 16 03 01 00 F8 01 00 00 F4 03 03 [32 bytes random] [session_id] [ciphers] [SNI...]
-// ├─────────────┤├──────────────────────────────────────────────────────────────────┤
-//
-//	TLS record       Payload (248 bytes)
-//	header (5B)
-//
-//	16    = Handshake
-//	03 01 = TLS 1.0 (record layer version)
-//	00 F8 = 248 bytes follow
-//
-//	01       = ClientHello (handshake type)
-//	00 00 F4 = 244 bytes of handshake body
-//	03 03    = TLS 1.2 (actual protocol version)
-//	...rest of ClientHello...
-//
-// Fragmented record look like:
-//
-//	Record 1:
-//
-// 16 03 01 00 03 01 00 00
-// ├─────────────┤├──────┤
-//
-//	TLS header    3 bytes of payload
-//
-//	16    = Handshake
-//	03 01 = TLS 1.0
-//	00 03 = only 3 bytes follow
-//
-//	01       = ClientHello type
-//	00 00    = first 2 bytes of the uint24 length (INCOMPLETE!)
-//
-// Record 2:
-// 16 03 01 00 F5 F4 03 03 [32 bytes random] [session_id] [ciphers] [SNI...]
-// ├─────────────┤├────────────────────────────────────────────────────────────┤
-//
-//	TLS header    remaining 245 bytes of payload
-//
-//	16    = Handshake
-//	03 01 = TLS 1.0
-//	00 F5 = 245 bytes follow
-//
-//	F4    = last byte of uint24 length (now complete: 00 00 F4 = 244)
-//	03 03 = TLS 1.2
-//	...rest of ClientHello continues...
-//
-// So it means that there could be a series of handshake packets of different
-// lengths. The goal of this function is to concatenate these fragments.
-type fragmentedHandshakeReader struct {
-	r             io.Reader
-	buf           bytes.Buffer
-	readFragments int
-}
-
-func (f *fragmentedHandshakeReader) Read(p []byte) (int, error) {
-	if n, err := f.buf.Read(p); err == nil {
-		return n, nil
-	}
-
-	f.buf.Reset()
-
-	for f.buf.Len() == 0 {
-		if f.readFragments > maxFragmentsCount {
-			return 0, ErrTooManyFragments
-		}
-
-		if err := f.parseNextFragment(); err != nil {
-			return 0, err
-		}
-
-		f.readFragments++
-	}
-
-	return f.buf.Read(p)
-}
-
-func (f *fragmentedHandshakeReader) parseNextFragment() error {
-	// record_type(1) + version(2) + size(2)
-	//   16 - type is 0x16 (handshake record)
-	//   03 01 - protocol version is "3,1" (also known as TLS 1.0)
-	//   00 f8 - 0xF8 (248) bytes of handshake message follows
-	header := [1 + 2 + 2]byte{}
-
-	if _, err := io.ReadFull(f.r, header[:]); err != nil {
-		return fmt.Errorf("cannot read record header: %w", err)
-	}
-
-	if header[0] != tls.TypeHandshake {
-		return fmt.Errorf("unexpected record type %#x", header[0])
-	}
-
-	if header[1] != 3 || header[2] != 1 {
-		return fmt.Errorf("unexpected protocol version %#x %#x", header[1], header[2])
-	}
-
-	length := int64(binary.BigEndian.Uint16(header[3:]))
-	_, err := io.CopyN(&f.buf, f.r, length)
-
-	return err
-}
-
-func parseClientHello(r io.Reader) (*bytes.Buffer, *bytes.Buffer, error) {
-	r = &fragmentedHandshakeReader{r: r}
-	header := [1 + 3]byte{}
-
-	if _, err := io.ReadFull(r, header[:]); err != nil {
-		return nil, nil, fmt.Errorf("cannot read handshake header: %w", err)
-	}
-
-	if header[0] != TypeHandshakeClient {
-		return nil, nil, fmt.Errorf("incorrect handshake type: %#x", header[0])
-	}
-
-	// unfortunately there is not uint24 in golang, so we just reuse header
-	header[0] = 0
-	length := int64(binary.BigEndian.Uint32(header[:]))
-
-	clientHelloCopy := &bytes.Buffer{}
-	clientHelloCopy.Write([]byte{tls.TypeHandshake, 3, 1})
-	binary.Write( //nolint: errcheck
-		clientHelloCopy,
-		binary.BigEndian,
-		// 1 for handshake type
-		// 3 for handshake length
-		uint16(1+3+length),
-	)
-	clientHelloCopy.WriteByte(TypeHandshakeClient)
-	clientHelloCopy.Write(header[1:])
-
-	handshakeCopy := &bytes.Buffer{}
-	writer := io.MultiWriter(clientHelloCopy, handshakeCopy)
-
-	_, err := io.CopyN(writer, r, length)
-
-	return clientHelloCopy, handshakeCopy, err
-}

mtglib/internal/tls/utils.go

@@ -29,24 +29,20 @@ func ReadRecord(r io.Reader, w io.Writer) (byte, int64, error) {
 
 func WriteRecord(w io.Writer, payload []byte) error {
 	buf := [MaxRecordSize]byte{}
-	copy(buf[SizeHeader:], payload)
+	buf[0] = TypeApplicationData
 
-	return WriteRecordInPlace(w, buf[:], len(payload))
-}
+	bufV := buf[SizeRecordType:]
+	copy(bufV[:SizeVersion], TLSVersion[:])
 
-func WriteRecordInPlace(w io.Writer, buf []byte, payloadLen int) error {
-	if payloadLen > MaxRecordPayloadSize {
-		return fmt.Errorf("payload %d exceeds max %d", payloadLen, MaxRecordPayloadSize)
+	bufS := bufV[SizeVersion:]
+	binary.BigEndian.PutUint16(bufS[:SizeSize], uint16(len(payload)))
+
+	bufP := buf[SizeHeader:]
+	if n := copy(bufP, payload); n != len(payload) {
+		return fmt.Errorf("copied %d bytes of payload instead of %d", n, len(payload))
 	}
 
-	buf[0] = TypeApplicationData
-	copy(buf[SizeRecordType:SizeRecordType+SizeVersion], TLSVersion[:])
-	binary.BigEndian.PutUint16(
-		buf[SizeRecordType+SizeVersion:SizeRecordType+SizeVersion+SizeSize],
-		uint16(payloadLen),
-	)
-
-	_, err := w.Write(buf[:SizeHeader+payloadLen])
+	_, err := w.Write(buf[:SizeHeader+len(payload)])
 
 	return err
 }

mtglib/internal/tls/utils_test.go

@@ -119,84 +119,6 @@ func (suite *UtilsTestSuite) TestWriteRecordPayloadTooLarge() {
 	suite.Error(err)
 }
 
-func (suite *UtilsTestSuite) TestWriteRecordInPlace() {
-	payload := []byte("hello in-place")
-
-	var buf [MaxRecordSize]byte
-	copy(buf[SizeHeader:], payload)
-
-	err := WriteRecordInPlace(suite.dst, buf[:], len(payload))
-	suite.NoError(err)
-
-	written := suite.dst.Bytes()
-	suite.Equal(byte(TypeApplicationData), written[0])
-	suite.Equal(TLSVersion[:], written[SizeRecordType:SizeRecordType+SizeVersion])
-
-	length := binary.BigEndian.Uint16(written[SizeRecordType+SizeVersion:])
-	suite.Equal(uint16(len(payload)), length)
-	suite.Equal(payload, written[SizeHeader:])
-}
-
-func (suite *UtilsTestSuite) TestWriteRecordInPlaceRoundTrip() {
-	payload := []byte("round trip in-place")
-
-	var buf [MaxRecordSize]byte
-	copy(buf[SizeHeader:], payload)
-
-	var wire bytes.Buffer
-
-	err := WriteRecordInPlace(&wire, buf[:], len(payload))
-	suite.NoError(err)
-
-	var recovered bytes.Buffer
-
-	recordType, length, err := ReadRecord(&wire, &recovered)
-	suite.NoError(err)
-	suite.Equal(byte(TypeApplicationData), recordType)
-	suite.Equal(int64(len(payload)), length)
-	suite.Equal(payload, recovered.Bytes())
-}
-
-func (suite *UtilsTestSuite) TestWriteRecordInPlacePayloadTooLarge() {
-	var buf [MaxRecordSize]byte
-
-	err := WriteRecordInPlace(suite.dst, buf[:], MaxRecordPayloadSize+1)
-	suite.Error(err)
-}
-
-func (suite *UtilsTestSuite) TestWriteRecordInPlacePropagatesError() {
-	m := &WriterMock{}
-	m.
-		On("Write", mock.AnythingOfType("[]uint8")).
-		Once().
-		Return(0, errors.New("disk full"))
-
-	var buf [MaxRecordSize]byte
-	copy(buf[SizeHeader:], []byte("data"))
-
-	err := WriteRecordInPlace(m, buf[:], 4)
-	suite.Error(err)
-
-	m.AssertExpectations(suite.T())
-}
-
-func (suite *UtilsTestSuite) TestWriteRecordInPlaceMatchesWriteRecord() {
-	payload := []byte("equivalence check")
-
-	var legacy bytes.Buffer
-	err := WriteRecord(&legacy, payload)
-	suite.NoError(err)
-
-	var buf [MaxRecordSize]byte
-	copy(buf[SizeHeader:], payload)
-
-	var inPlace bytes.Buffer
-	err = WriteRecordInPlace(&inPlace, buf[:], len(payload))
-	suite.NoError(err)
-
-	suite.Equal(legacy.Bytes(), inPlace.Bytes())
-}
-
 func TestUtils(t *testing.T) {
 	t.Parallel()
 	suite.Run(t, &UtilsTestSuite{})

mtglib/proxy.go

@@ -27,8 +27,6 @@ type Proxy struct {
 
 	allowFallbackOnUnknownDC    bool
 	tolerateTimeSkewness        time.Duration
-	idleTimeout                 time.Duration
-	handshakeTimeout            time.Duration
 	domainFrontingPort          int
 	domainFrontingIP            string
 	domainFrontingProxyProtocol bool
@@ -67,15 +65,10 @@ func (p *Proxy) ServeConn(conn essentials.Conn) {
 	ctx := newStreamContext(p.ctx, p.logger, conn)
 	defer ctx.Close()
 
-	if err := ctx.clientConn.SetDeadline(time.Now().Add(p.handshakeTimeout)); err != nil {
-		ctx.logger.WarningError("cannot set handshake timeout", err)
-		return
-	}
-
-	stop := context.AfterFunc(ctx, func() {
+	go func() {
+		<-ctx.Done()
 		ctx.Close()
-	})
-	defer stop()
+	}()
 
 	p.eventStream.Send(ctx, NewEventStart(ctx.streamID, ctx.ClientIP()))
 	ctx.logger.Info("Stream has been started")
@@ -103,23 +96,16 @@ func (p *Proxy) ServeConn(conn essentials.Conn) {
 		return
 	}
 
-	if err := ctx.clientConn.SetDeadline(time.Time{}); err != nil {
-		ctx.logger.WarningError("cannot set deadline", err)
-		return
-	}
-
 	if err := p.doTelegramCall(ctx); err != nil {
 		ctx.logger.WarningError("cannot dial to telegram", err)
 		return
 	}
 
-	tracker := newIdleTracker(p.idleTimeout)
-
 	relay.Relay(
 		ctx,
 		ctx.logger.Named("relay"),
-		connIdleTimeout{Conn: ctx.telegramConn, tracker: tracker},
-		connIdleTimeout{Conn: ctx.clientConn, tracker: tracker},
+		ctx.telegramConn,
+		ctx.clientConn,
 	)
 }
 
@@ -165,7 +151,6 @@ func (p *Proxy) Serve(listener net.Listener) error {
 		case errors.Is(err, ants.ErrPoolClosed):
 			return nil
 		case errors.Is(err, ants.ErrPoolOverload):
-			conn.Close() //nolint: errcheck
 			logger.Info("connection was concurrency limited")
 			p.eventStream.Send(p.ctx, NewEventConcurrencyLimited())
 		}
@@ -207,10 +192,7 @@ func (p *Proxy) doFakeTLSHandshake(ctx *streamContext) bool {
 		return false
 	}
 
-	gangerNoise := p.doppelGanger.NoiseParams()
-	noiseParams := fake.NoiseParams{Mean: gangerNoise.Mean, Jitter: gangerNoise.Jitter}
-
-	if err := fake.SendServerHello(ctx.clientConn, p.secret.Key[:], clientHello, noiseParams); err != nil {
+	if err := fake.SendServerHello(ctx.clientConn, p.secret.Key[:], clientHello); err != nil {
 		p.logger.InfoError("cannot send welcome packet", err)
 		return false
 	}
@@ -277,16 +259,9 @@ func (p *Proxy) doTelegramCall(ctx *streamContext) error {
 		ctx:      ctx,
 	}
 
-	telegramHost, _, err := net.SplitHostPort(foundAddr.Address)
-	if err != nil {
-		conn.Close() //nolint: errcheck
-
-		return fmt.Errorf("cannot parse telegram address %s: %w", foundAddr.Address, err)
-	}
-
 	p.eventStream.Send(ctx,
 		NewEventConnectedToDC(ctx.streamID,
-			net.ParseIP(telegramHost),
+			conn.RemoteAddr().(*net.TCPAddr).IP, //nolint: forcetypeassert
 			ctx.dc),
 	)
 
@@ -318,13 +293,11 @@ func (p *Proxy) doDomainFronting(ctx *streamContext, conn *connRewind) {
 		stream:   p.eventStream,
 	}
 
-	tracker := newIdleTracker(p.idleTimeout)
-
 	relay.Relay(
 		ctx,
 		ctx.logger.Named("domain-fronting"),
-		connIdleTimeout{Conn: frontConn, tracker: tracker},
-		connIdleTimeout{Conn: conn, tracker: tracker},
+		frontConn,
+		conn,
 	)
 }
 
@@ -356,8 +329,6 @@ func NewProxy(opts ProxyOpts) (*Proxy, error) {
 		domainFrontingPort:       opts.getDomainFrontingPort(),
 		domainFrontingIP:         opts.DomainFrontingIP,
 		tolerateTimeSkewness:     opts.getTolerateTimeSkewness(),
-		idleTimeout:              opts.getIdleTimeout(),
-		handshakeTimeout:         opts.getHandshakeTimeout(),
 		allowFallbackOnUnknownDC: opts.AllowFallbackOnUnknownDC,
 		telegram:                 tg,
 		doppelGanger: doppel.NewGanger(

mtglib/proxy_opts.go

@@ -70,12 +70,6 @@ type ProxyOpts struct {
 	// This is an optional setting.
 	IdleTimeout time.Duration
 
-	// HandshakeTimeout is a timeout during which all handshake ceremonies must
-	// be completed, otherwise this process will be aborted
-	//
-	// This is an optional setting.
-	HandshakeTimeout time.Duration
-
 	// TolerateTimeSkewness is a time boundary that defines a time range where
 	// faketls timestamp is acceptable.
 	//
@@ -221,22 +215,6 @@ func (p ProxyOpts) getPreferIP() string {
 	return p.PreferIP
 }
 
-func (p ProxyOpts) getHandshakeTimeout() time.Duration {
-	if p.HandshakeTimeout == 0 {
-		return DefaultHandshakeTimeout
-	}
-
-	return p.HandshakeTimeout
-}
-
-func (p ProxyOpts) getIdleTimeout() time.Duration {
-	if p.IdleTimeout == 0 {
-		return DefaultIdleTimeout
-	}
-
-	return p.IdleTimeout
-}
-
 func (p ProxyOpts) getLogger(name string) Logger {
 	return p.Logger.Named(name)
 }

mtglib/proxy_test.go

@@ -175,7 +175,7 @@ func (suite *ProxyTestSuite) TestHTTPSRequest() {
 	addr := fmt.Sprintf("https://%s/headers", suite.ProxyAddress())
 
 	resp, err := client.Get(addr) //nolint: noctx
-	suite.Require().NoError(err)
+	suite.NoError(err)
 
 	defer resp.Body.Close() //nolint: errcheck
 

network/init.go

@@ -36,22 +36,8 @@ const (
 
 	// DefaultTCPKeepAlivePeriod defines a time period between 2 consequitive
 	// probes.
-	//
-	// Deprecated: use DefaultKeepAliveIdle and DefaultKeepAliveInterval instead.
 	DefaultTCPKeepAlivePeriod = 10 * time.Second
 
-	// DefaultKeepAliveIdle is the time a connection must be idle before
-	// the first keepalive probe is sent.
-	DefaultKeepAliveIdle = 30 * time.Second
-
-	// DefaultKeepAliveInterval is the time between consecutive keepalive
-	// probes.
-	DefaultKeepAliveInterval = 10 * time.Second
-
-	// DefaultKeepAliveCount is the number of unacknowledged probes before
-	// the connection is considered dead.
-	DefaultKeepAliveCount = 3
-
 	// ProxyDialerOpenThreshold is used for load balancing SOCKS5 dialer only.
 	//
 	// This dialer uses circuit breaker with of 3 stages: OPEN, HALF_OPEN and

network/sockopts.go

@@ -20,13 +20,8 @@ func SetServerSocketOptions(conn net.Conn, bufferSize int) error {
 }
 
 func setCommonSocketOptions(conn *net.TCPConn) error {
-	if err := conn.SetKeepAliveConfig(net.KeepAliveConfig{
-		Enable:   true,
-		Idle:     DefaultKeepAliveIdle,
-		Interval: DefaultKeepAliveInterval,
-		Count:    DefaultKeepAliveCount,
-	}); err != nil {
-		return fmt.Errorf("cannot configure TCP keepalive: %w", err)
+	if err := conn.SetKeepAlivePeriod(DefaultTCPKeepAlivePeriod); err != nil {
+		return fmt.Errorf("cannot set time period of TCP keepalive probes: %w", err)
 	}
 
 	if err := conn.SetLinger(tcpLingerTimeout); err != nil {

network/sockopts_test.go

@@ -1,93 +0,0 @@
-//go:build linux || darwin
-// +build linux darwin
-
-package network_test
-
-import (
-	"net"
-	"runtime"
-	"syscall"
-	"testing"
-	"time"
-
-	"github.com/9seconds/mtg/v2/network"
-	"github.com/stretchr/testify/require"
-	"golang.org/x/sys/unix"
-)
-
-func tcpKeepIdleOption() int {
-	if runtime.GOOS == "darwin" {
-		return 0x10 // TCP_KEEPALIVE on macOS
-	}
-
-	return 0x4 // TCP_KEEPIDLE on Linux
-}
-
-func TestSetClientSocketOptionsKeepAlive(t *testing.T) {
-	t.Parallel()
-
-	listener, err := net.Listen("tcp", "127.0.0.1:0")
-	require.NoError(t, err)
-	defer func() {
-		err := listener.Close()
-		require.NoError(t, err)
-	}()
-
-	type dialResult struct {
-		conn net.Conn
-		err  error
-	}
-
-	dialDone := make(chan dialResult, 1)
-
-	go func() {
-		c, err := net.Dial("tcp", listener.Addr().String())
-		dialDone <- dialResult{conn: c, err: err}
-	}()
-
-	tcpListener, ok := listener.(*net.TCPListener)
-	require.True(t, ok, "listener must be a *net.TCPListener")
-
-	require.NoError(t, tcpListener.SetDeadline(time.Now().Add(5*time.Second)))
-
-	accepted, err := listener.Accept()
-	require.NoError(t, err)
-	defer func() {
-		err := accepted.Close()
-		require.NoError(t, err)
-	}()
-
-	dr := <-dialDone
-	require.NoError(t, dr.err)
-	defer func() {
-		err := dr.conn.Close()
-		require.NoError(t, err)
-	}()
-
-	err = network.SetClientSocketOptions(accepted, 0)
-	require.NoError(t, err)
-
-	tcpConn := accepted.(*net.TCPConn)
-
-	rawConn, err := tcpConn.SyscallConn()
-	require.NoError(t, err)
-
-	err = rawConn.Control(func(fd uintptr) {
-		val, err := unix.GetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_KEEPALIVE)
-		require.NoError(t, err)
-		require.NotEqual(t, 0, val, "SO_KEEPALIVE should be enabled")
-
-		idle, err := unix.GetsockoptInt(int(fd), syscall.IPPROTO_TCP, tcpKeepIdleOption())
-		require.NoError(t, err)
-		require.Equal(t, int(network.DefaultKeepAliveIdle.Seconds()), idle)
-
-		interval, err := unix.GetsockoptInt(int(fd), syscall.IPPROTO_TCP, unix.TCP_KEEPINTVL)
-		require.NoError(t, err)
-		require.Equal(t, int(network.DefaultKeepAliveInterval.Seconds()), interval)
-
-		count, err := unix.GetsockoptInt(int(fd), syscall.IPPROTO_TCP, unix.TCP_KEEPCNT)
-		require.NoError(t, err)
-		require.Equal(t, network.DefaultKeepAliveCount, count)
-	})
-	require.NoError(t, err)
-}

network/v2/base_http_test.go

@@ -25,7 +25,7 @@ func (suite *BaseHTTPTestSuite) SetupSuite() {
 }
 
 func (suite *BaseHTTPTestSuite) SetupTest() {
-	suite.client = network.New(nil, "mtg/1", 0, 0, 0, network.DefaultKeepAliveConfig).MakeHTTPClient(nil)
+	suite.client = network.New(nil, "mtg/1", 0, 0, 0).MakeHTTPClient(nil)
 }
 
 func (suite *BaseHTTPTestSuite) TestGet() {

network/v2/base_network_test.go

@@ -19,7 +19,7 @@ type BaseNetworkTestSuite struct {
 func (suite *BaseNetworkTestSuite) SetupSuite() {
 	suite.EchoServerTestSuite.SetupSuite()
 
-	suite.net = network.New(nil, "agent", 0, 0, 0, network.DefaultKeepAliveConfig)
+	suite.net = network.New(nil, "agent", 0, 0, 0)
 }
 
 func (suite *BaseNetworkTestSuite) TestDialUnknownNetwork() {

network/v2/init.go

@@ -11,7 +11,6 @@ package network
 
 import (
 	"errors"
-	"net"
 	"time"
 )
 
@@ -27,55 +26,14 @@ const (
 
 	// DefaultTCPKeepAlivePeriod defines a time period between 2 consecuitive
 	// probes.
-	//
-	// Deprecated: use DefaultKeepAliveConfig
 	DefaultTCPKeepAlivePeriod = 10 * time.Second
 
-	// DefaultKeepAliveIdle is the time a connection must be idle before
-	// the first keepalive probe is sent.
-	//
-	// Deprecated: use DefaultKeepAliveConfig
-	DefaultKeepAliveIdle = 30 * time.Second
-
-	// DefaultKeepAliveInterval is the time between consecutive keepalive
-	// probes.
-	//
-	// Deprecated: use DefaultKeepAliveConfig
-	DefaultKeepAliveInterval = 10 * time.Second
-
-	// DefaultKeepAliveCount is the number of unacknowledged probes before
-	// the connection is considered dead.
-	//
-	// Deprecated: use DefaultKeepAliveConfig
-	DefaultKeepAliveCount = 3
-
 	// User Agent to use in HTTP client.
 	UserAgent = "curl/8.5.0"
 
 	// tcpLingerTimeout defines a number of seconds to wait for sending
 	// unacknowledged data.
 	tcpLingerTimeout = 1
-
-	// tcpNotSentLowat limits the amount of unsent data queued in the
-	// kernel write buffer per socket. When the unsent data drops below
-	// this threshold, the socket becomes writable again. This reduces
-	// per-connection memory usage and bufferbloat by applying
-	// back-pressure to the relay loop instead of piling up data in
-	// kernel buffers.
-	tcpNotSentLowat = 128 * 1024
 )
 
-var (
-	ErrCannotDial = errors.New("cannot dial to any address")
-
-	// DefaultKeepAliveConfig defines a default configuration for
-	// keep alive settings. As per official documentation, if keep alive
-	// is enabled, then:
-	//
-	//  Idle = 15 * time.Second
-	//  Interval = 15 * time.Second
-	//  Count = 9
-	DefaultKeepAliveConfig = net.KeepAliveConfig{
-		Enable: true,
-	}
-)
+var ErrCannotDial = errors.New("cannot dial to any address")

network/v2/network.go

@@ -14,10 +14,9 @@ import (
 type network struct {
 	net.Dialer
 
-	keepAliveConfig net.KeepAliveConfig
-	httpTimeout     time.Duration
-	idleTimeout     time.Duration
-	userAgent       string
+	httpTimeout time.Duration
+	idleTimeout time.Duration
+	userAgent   string
 }
 
 func (n *network) Dial(network, address string) (essentials.Conn, error) {
@@ -38,7 +37,7 @@ func (n *network) DialContext(ctx context.Context, network, address string) (ess
 
 	tcpConn := conn.(*net.TCPConn)
 
-	return tcpConn, setCommonSocketOptions(tcpConn, n.keepAliveConfig)
+	return tcpConn, setCommonSocketOptions(tcpConn)
 }
 
 func (n *network) MakeHTTPClient(
@@ -72,7 +71,6 @@ func New(
 	tcpTimeout,
 	httpTimeout,
 	idleTimeout time.Duration,
-	keepAliveConfig net.KeepAliveConfig,
 ) mtglib.Network {
 	if dnsResolver == nil {
 		dnsResolver = net.DefaultResolver
@@ -88,9 +86,8 @@ func New(
 			Resolver:      dnsResolver,
 			FallbackDelay: -1,
 		},
-		userAgent:       userAgent,
-		idleTimeout:     idleTimeout,
-		httpTimeout:     httpTimeout,
-		keepAliveConfig: keepAliveConfig,
+		userAgent:   userAgent,
+		idleTimeout: idleTimeout,
+		httpTimeout: httpTimeout,
 	}
 }

network/v2/proxy_network.go

@@ -3,7 +3,6 @@ package network
 import (
 	"context"
 	"fmt"
-	"net/http"
 	"net/url"
 
 	"github.com/9seconds/mtg/v2/essentials"
@@ -16,10 +15,6 @@ type proxyNetwork struct {
 	client proxy.ContextDialer
 }
 
-func (p proxyNetwork) Dial(network, address string) (essentials.Conn, error) {
-	return p.DialContext(context.Background(), network, address)
-}
-
 func (p proxyNetwork) DialContext(ctx context.Context, network, address string) (essentials.Conn, error) {
 	conn, err := p.client.DialContext(ctx, network, address)
 	if err != nil {
@@ -29,16 +24,6 @@ func (p proxyNetwork) DialContext(ctx context.Context, network, address string)
 	return essentials.WrapNetConn(conn), nil
 }
 
-func (p proxyNetwork) MakeHTTPClient(
-	dialFunc func(context.Context, string, string) (essentials.Conn, error),
-) *http.Client {
-	if dialFunc == nil {
-		dialFunc = p.DialContext
-	}
-
-	return p.Network.MakeHTTPClient(dialFunc)
-}
-
 func NewProxyNetwork(base mtglib.Network, proxyURL *url.URL) (*proxyNetwork, error) {
 	socks, err := proxy.FromURL(proxyURL, base.NativeDialer())
 	if err != nil {

network/v2/sockopts.go

@@ -5,9 +5,9 @@ import (
 	"net"
 )
 
-func setCommonSocketOptions(conn *net.TCPConn, keepAliveConfig net.KeepAliveConfig) error {
-	if err := conn.SetKeepAliveConfig(keepAliveConfig); err != nil {
-		return fmt.Errorf("cannot configure TCP keepalive: %w", err)
+func setCommonSocketOptions(conn *net.TCPConn) error {
+	if err := conn.SetKeepAlivePeriod(DefaultTCPKeepAlivePeriod); err != nil {
+		return fmt.Errorf("cannot set time period of TCP keepalive probes: %w", err)
 	}
 
 	if err := conn.SetLinger(tcpLingerTimeout); err != nil {
@@ -23,9 +23,5 @@ func setCommonSocketOptions(conn *net.TCPConn, keepAliveConfig net.KeepAliveConf
 		return fmt.Errorf("cannot setup SO_REUSEADDR/PORT: %w", err)
 	}
 
-	setCongestionControl(rawConn)
-	setTCPUserTimeout(rawConn, keepAliveConfig)
-	setNotSentLowat(rawConn)
-
 	return nil
 }

network/v2/sockopts_congestion.go

@@ -1,20 +0,0 @@
-//go:build linux
-
-package network
-
-import (
-	"syscall"
-
-	"golang.org/x/sys/unix"
-)
-
-// setCongestionControl sets BBR as the TCP congestion control algorithm.
-// BBR provides better throughput over lossy and high-latency links compared
-// to the default cubic, which is especially beneficial for mobile and
-// home internet clients. This is best-effort: silently ignored if the
-// kernel does not have tcp_bbr available.
-func setCongestionControl(conn syscall.RawConn) {
-	conn.Control(func(fd uintptr) { //nolint: errcheck
-		unix.SetsockoptString(int(fd), unix.IPPROTO_TCP, unix.TCP_CONGESTION, "bbr") //nolint: errcheck
-	})
-}

network/v2/sockopts_congestion_stub.go

@@ -1,7 +0,0 @@
-//go:build !linux
-
-package network
-
-import "syscall"
-
-func setCongestionControl(conn syscall.RawConn) {}

network/v2/sockopts_lowat.go

@@ -1,20 +0,0 @@
-//go:build linux || darwin
-
-package network
-
-import (
-	"syscall"
-
-	"golang.org/x/sys/unix"
-)
-
-// setNotSentLowat sets TCP_NOTSENT_LOWAT which limits the amount of
-// unsent data queued in the kernel write buffer. Once unsent data drops
-// below this threshold the socket becomes writable again, applying
-// back-pressure to the relay loop instead of piling up data in kernel
-// buffers. This reduces per-connection memory and bufferbloat.
-func setNotSentLowat(conn syscall.RawConn) {
-	conn.Control(func(fd uintptr) { //nolint: errcheck
-		unix.SetsockoptInt(int(fd), unix.IPPROTO_TCP, unix.TCP_NOTSENT_LOWAT, tcpNotSentLowat) //nolint: errcheck
-	})
-}

network/v2/sockopts_lowat_stub.go

@@ -1,7 +0,0 @@
-//go:build !linux && !darwin
-
-package network
-
-import "syscall"
-
-func setNotSentLowat(conn syscall.RawConn) {}

network/v2/sockopts_test.go

@@ -1,92 +0,0 @@
-//go:build linux || darwin
-// +build linux darwin
-
-package network
-
-import (
-	"net"
-	"runtime"
-	"syscall"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-	"golang.org/x/sys/unix"
-)
-
-func tcpKeepIdleOption() int {
-	if runtime.GOOS == "darwin" {
-		return 0x10 // TCP_KEEPALIVE on macOS
-	}
-
-	return 0x4 // TCP_KEEPIDLE on Linux
-}
-
-func TestSetCommonSocketOptionsKeepAlive(t *testing.T) {
-	t.Parallel()
-
-	listener, err := net.Listen("tcp", "127.0.0.1:0")
-	require.NoError(t, err)
-	defer func() {
-		err := listener.Close()
-		require.NoError(t, err)
-	}()
-
-	type dialResult struct {
-		conn net.Conn
-		err  error
-	}
-
-	dialDone := make(chan dialResult, 1)
-
-	go func() {
-		c, err := net.Dial("tcp", listener.Addr().String())
-		dialDone <- dialResult{conn: c, err: err}
-	}()
-
-	tcpListener, ok := listener.(*net.TCPListener)
-	require.True(t, ok, "listener must be a *net.TCPListener")
-
-	require.NoError(t, tcpListener.SetDeadline(time.Now().Add(5*time.Second)))
-
-	accepted, err := listener.Accept()
-	require.NoError(t, err)
-	defer func() {
-		err := accepted.Close()
-		require.NoError(t, err)
-	}()
-
-	dr := <-dialDone
-	require.NoError(t, dr.err)
-	defer func() {
-		err := dr.conn.Close()
-		require.NoError(t, err)
-	}()
-
-	tcpConn := accepted.(*net.TCPConn)
-
-	err = setCommonSocketOptions(tcpConn, DefaultKeepAliveConfig)
-	require.NoError(t, err)
-
-	rawConn, err := tcpConn.SyscallConn()
-	require.NoError(t, err)
-
-	err = rawConn.Control(func(fd uintptr) {
-		val, err := unix.GetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_KEEPALIVE)
-		require.NoError(t, err)
-		require.NotEqual(t, 0, val, "SO_KEEPALIVE should be enabled")
-
-		idle, err := unix.GetsockoptInt(int(fd), syscall.IPPROTO_TCP, tcpKeepIdleOption())
-		require.NoError(t, err)
-		require.Equal(t, 15, idle, "keepalive idle should match DefaultKeepAliveIdle")
-
-		interval, err := unix.GetsockoptInt(int(fd), syscall.IPPROTO_TCP, unix.TCP_KEEPINTVL)
-		require.NoError(t, err)
-		require.Equal(t, 15, interval, "keepalive interval should match DefaultKeepAliveInterval")
-
-		count, err := unix.GetsockoptInt(int(fd), syscall.IPPROTO_TCP, unix.TCP_KEEPCNT)
-		require.NoError(t, err)
-		require.Equal(t, 9, count, "keepalive count should match DefaultKeepAliveCount")
-	})
-	require.NoError(t, err)
-}

network/v2/sockopts_unix.go

@@ -1,4 +1,5 @@
 //go:build !windows
+// +build !windows
 
 package network
 

network/v2/sockopts_usertimeout.go

@@ -1,48 +0,0 @@
-//go:build linux
-
-package network
-
-import (
-	"net"
-	"syscall"
-	"time"
-
-	"golang.org/x/sys/unix"
-)
-
-// Go runtime defaults for KeepAliveConfig when fields are zero.
-const (
-	goDefaultKeepAliveIdle     = 15 * time.Second
-	goDefaultKeepAliveInterval = 15 * time.Second
-	goDefaultKeepAliveCount    = 9
-)
-
-// setTCPUserTimeout sets TCP_USER_TIMEOUT on a socket. If transmitted
-// data remains unacknowledged for this long, the kernel closes the
-// connection. As recommended by Cloudflare
-// (https://blog.cloudflare.com/when-tcp-sockets-refuse-to-die/),
-// the value is computed as: keepidle + keepintvl * keepcnt. This
-// ensures TCP_USER_TIMEOUT and keepalives agree on when to give up.
-// Best-effort: silently ignored if unsupported.
-func setTCPUserTimeout(conn syscall.RawConn, cfg net.KeepAliveConfig) {
-	idle := cfg.Idle
-	if idle == 0 {
-		idle = goDefaultKeepAliveIdle
-	}
-
-	interval := cfg.Interval
-	if interval == 0 {
-		interval = goDefaultKeepAliveInterval
-	}
-
-	count := cfg.Count
-	if count == 0 {
-		count = goDefaultKeepAliveCount
-	}
-
-	timeout := idle + interval*time.Duration(count)
-
-	conn.Control(func(fd uintptr) { //nolint: errcheck
-		unix.SetsockoptInt(int(fd), unix.IPPROTO_TCP, unix.TCP_USER_TIMEOUT, int(timeout.Milliseconds())) //nolint: errcheck
-	})
-}

network/v2/sockopts_usertimeout_stub.go

@@ -1,10 +0,0 @@
-//go:build !linux
-
-package network
-
-import (
-	"net"
-	"syscall"
-)
-
-func setTCPUserTimeout(conn syscall.RawConn, cfg net.KeepAliveConfig) {}

network/v2/sockopts_windows.go

@@ -1,4 +1,5 @@
 //go:build windows
+// +build windows
 
 package network
 

network/v2/socks_proxy_test.go

@@ -66,7 +66,7 @@ func (suite *SocksProxyTestSuite) SetupSuite() {
 	require.NoError(suite.T(), err)
 	suite.authURL = parsed
 
-	suite.baseNetwork = network.New(nil, "mtg", 0, 0, 0, network.DefaultKeepAliveConfig)
+	suite.baseNetwork = network.New(nil, "mtg", 0, 0, 0)
 }
 
 func (suite *SocksProxyTestSuite) TestIncorrectSchema() {

run_profile.go

@@ -1,6 +0,0 @@
-//go:build !prof
-
-package main
-
-func runProfile() {
-}

run_profile_tag_prof.go

@@ -1,26 +0,0 @@
-//go:build prof
-
-package main
-
-import (
-	"net"
-	"net/http"
-	_ "net/http/pprof" //nolint: gosec
-	"os"
-)
-
-const DefaultProfPort = "6000"
-
-func runProfile() {
-	port := os.Getenv("MTG_PROF_PORT")
-	if port == "" {
-		port = DefaultProfPort
-	}
-
-	listener, err := net.Listen("tcp", net.JoinHostPort("127.0.0.1", port))
-	if err != nil {
-		panic(err)
-	}
-
-	go http.Serve(listener, nil)
-}