1.add tcp kill/mon functions 2.support win 7 again 3.fix tcp keepalive period too fast on windows 4.other bug fix

go.mod

@@ -1,10 +1,9 @@
 module b612.me/apps/b612
 
-go 1.21.2
+go 1.20
-
-toolchain go1.22.4
 
 require (
+	b612.me/bcap v0.0.4
 	b612.me/notify v1.2.6
 	b612.me/sdk/whois v0.0.0-20240816133027-129514a15991
 	b612.me/starcrypto v0.0.5
@@ -19,20 +18,23 @@ require (
 	github.com/elazarl/goproxy v0.0.0-20231117061959-7cc037d33fb5
 	github.com/elazarl/goproxy/ext v0.0.0-20190711103511-473e67f1d7d2
 	github.com/emersion/go-smtp v0.20.2
+	github.com/florianl/go-nfqueue/v2 v2.0.0
 	github.com/go-acme/lego/v4 v4.16.1
 	github.com/goftp/file-driver v0.0.0-20180502053751-5d604a0fc0c9
 	github.com/goftp/server v0.0.0-20200708154336-f64f7c2d8a42
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0
+	github.com/google/gopacket v1.1.19
 	github.com/huin/goupnp v1.3.0
 	github.com/inconshreveable/mousetrap v1.1.0
 	github.com/miekg/dns v1.1.58
 	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
+	github.com/shirou/gopsutil/v4 v4.24.10
 	github.com/spf13/cobra v1.8.0
 	github.com/things-go/go-socks5 v0.0.5
 	github.com/vbauerster/mpb/v8 v8.8.3
 	golang.org/x/crypto v0.26.0
 	golang.org/x/net v0.28.0
-	golang.org/x/sys v0.24.0
+	golang.org/x/sys v0.26.0
 	software.sslmate.com/src/go-pkcs12 v0.4.0
 )
 
@@ -50,28 +52,36 @@ require (
 	github.com/cenkalti/backoff/v4 v4.2.1 // indirect
 	github.com/cloudflare/cloudflare-go v0.86.0 // indirect
 	github.com/cpu/goacmedns v0.1.1 // indirect
+	github.com/ebitengine/purego v0.8.1 // indirect
 	github.com/emersion/go-sasl v0.0.0-20200509203442-7bfe0ed36a21 // indirect
 	github.com/go-jose/go-jose/v4 v4.0.1 // indirect
+	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/goccy/go-json v0.10.2 // indirect
 	github.com/golang-jwt/jwt/v4 v4.5.0 // indirect
+	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/google/go-querystring v1.1.0 // indirect
 	github.com/google/uuid v1.3.1 // indirect
 	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
 	github.com/hashicorp/go-retryablehttp v0.7.5 // indirect
 	github.com/jlaffaye/ftp v0.1.0 // indirect
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
+	github.com/josharian/native v1.1.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/kr/fs v0.1.0 // indirect
 	github.com/kylelemons/godebug v1.1.0 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/mdlayher/netlink v1.7.2 // indirect
+	github.com/mdlayher/socket v0.4.1 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8 // indirect
 	github.com/pkg/sftp v1.13.4 // indirect
+	github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common v1.0.490 // indirect
 	github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/dnspod v1.0.490 // indirect
+	github.com/yusufpapurcu/wmi v1.2.4 // indirect
 	golang.org/x/image v0.6.0 // indirect
 	golang.org/x/mod v0.17.0 // indirect
 	golang.org/x/sync v0.8.0 // indirect

go.sum

@@ -1,3 +1,5 @@
+b612.me/bcap v0.0.4 h1:iY2Oz+uyG/mue6a/dJiU82ci5Xwkj4xHhre/q0O8G60=
+b612.me/bcap v0.0.4/go.mod h1:tpus+4iMpsnxb98Pck70s87Zt4sIWuRZjK23MmmzmoY=
 b612.me/notify v1.2.5/go.mod h1:GTnAdC6v9krGxtC8Gkn8TcyUsYnHSiHjRAXsONPiLpI=
 b612.me/notify v1.2.6 h1:fY+0ccP6cJCDvnfRilmPlDK+J8xTYBpYNwf7jaC2IIE=
 b612.me/notify v1.2.6/go.mod h1:awcFq3bvbkf3hdviUtOW16Io0IEJXkNPgno7IRe7B9g=
@@ -36,11 +38,9 @@ github.com/Azure/azure-sdk-for-go/sdk/internal v1.3.0/go.mod h1:okt5dMMTOFjX/aov
 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/dns/armdns v1.1.0 h1:8iR6OLffWWorFdzL2JFCab5xpD8VKEE2DUBBl+HNTDY=
 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/dns/armdns v1.1.0/go.mod h1:copqlcjMWc/wgQ1N2fzsJFQxDdqKGg1EQt8T5wJMOGE=
 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/internal v1.1.2 h1:mLY+pNLjCUeKhgnAJWAKhEUQM+RJQo2H1fuGSw1Ky1E=
-github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/internal v1.1.2/go.mod h1:FbdwsQ2EzwvXxOPcMFYO8ogEc9uMMIj3YkmCdXdAFmk=
 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/privatedns/armprivatedns v1.1.0 h1:rR8ZW79lE/ppfXTfiYSnMFv5EzmVuY4pfZWIkscIJ64=
 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/privatedns/armprivatedns v1.1.0/go.mod h1:y2zXtLSMM/X5Mfawq0lOftpWn3f4V6OCsRdINsvWBPI=
 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources v1.0.0 h1:ECsQtyERDVz3NP3kvDOTLvbQhqWp/x9EsGKtb4ogUr8=
-github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources v1.0.0/go.mod h1:s1tW/At+xHqjNFvWU4G0c0Qv33KOhvbGNj0RCTQDV8s=
 github.com/AzureAD/microsoft-authentication-library-for-go v1.0.0 h1:OBhqkivkhkMqLPymWEppkm7vgPQY2XsHoEkaMQ0AdZY=
 github.com/AzureAD/microsoft-authentication-library-for-go v1.0.0/go.mod h1:kgDmCTgBzIEPFElEF+FK0SdjAor06dRq2Go927dnQ6o=
 github.com/VividCortex/ewma v1.2.0 h1:f58SaIzcDXrSy3kWaHNvuJgJ3Nmz59Zji6XoJR/q1ow=
@@ -60,7 +60,8 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 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/dnaeon/go-vcr v1.2.0 h1:zHCHvJYTMh1N7xnV7zf1m1GPBF9Ad0Jk/whtQ1663qI=
-github.com/dnaeon/go-vcr v1.2.0/go.mod h1:R4UdLID7HZT3taECzJs4YgbbH6PIGXB6W/sc5OLb6RQ=
+github.com/ebitengine/purego v0.8.1 h1:sdRKd6plj7KYW33EH5As6YKfe8m9zbN9JMrOjNVF/BE=
+github.com/ebitengine/purego v0.8.1/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
 github.com/elazarl/goproxy v0.0.0-20231117061959-7cc037d33fb5 h1:m62nsMU279qRD9PQSWD1l66kmkXzuYcnVJqL4XLeV2M=
 github.com/elazarl/goproxy v0.0.0-20231117061959-7cc037d33fb5/go.mod h1:Ro8st/ElPeALwNFlcTpWmkr6IoMFfkjXAvTHpevnDsM=
 github.com/elazarl/goproxy/ext v0.0.0-20190711103511-473e67f1d7d2 h1:dWB6v3RcOy03t/bUadywsbyrQwCqZeNIEX6M1OtSZOM=
@@ -70,11 +71,14 @@ github.com/emersion/go-sasl v0.0.0-20200509203442-7bfe0ed36a21/go.mod h1:iL2twTe
 github.com/emersion/go-smtp v0.20.2 h1:peX42Qnh5Q0q3vrAnRy43R/JwTnnv75AebxbkTL7Ia4=
 github.com/emersion/go-smtp v0.20.2/go.mod h1:qm27SGYgoIPRot6ubfQ/GpiPy/g3PaZAVRxiO/sDUgQ=
 github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
-github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
+github.com/florianl/go-nfqueue/v2 v2.0.0 h1:NTCxS9b0GSbHkWv1a7oOvZn679fsyDkaSkRvOYpQ9Oo=
+github.com/florianl/go-nfqueue/v2 v2.0.0/go.mod h1:M2tBLIj62QpwqjwV0qfcjqGOqP3qiTuXr2uSRBXH9Qk=
 github.com/go-acme/lego/v4 v4.16.1 h1:JxZ93s4KG0jL27rZ30UsIgxap6VGzKuREsSkkyzeoCQ=
 github.com/go-acme/lego/v4 v4.16.1/go.mod h1:AVvwdPned/IWpD/ihHhMsKnveF7HHYAz/CmtXi7OZoE=
 github.com/go-jose/go-jose/v4 v4.0.1 h1:QVEPDE3OluqXBQZDcnNvQrInro2h0e4eqNbnZSWqS6U=
 github.com/go-jose/go-jose/v4 v4.0.1/go.mod h1:WVf9LFMHh/QVrmqrOfqun0C45tMe3RoiKJMPvgWwLfY=
+github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
+github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
 github.com/goftp/file-driver v0.0.0-20180502053751-5d604a0fc0c9 h1:cC0Hbb+18DJ4i6ybqDybvj4wdIDS4vnD0QEci98PgM8=
@@ -92,17 +96,16 @@ github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeN
 github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
 github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/gopacket v1.1.19 h1:ves8RnFZPGiFnTS0uPQStjwru6uO6h+nlr9j6fL7kF8=
+github.com/google/gopacket v1.1.19/go.mod h1:iJ8V8n6KS+z2U1A8pUwu8bW5SyEMkXJB8Yo/Vo+TKTo=
 github.com/google/uuid v1.3.1 h1:KjJaJ9iWZ3jOFZIf1Lqf4laDRCasjl0BCmnEGxkdLb4=
 github.com/google/uuid v1.3.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
-github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
 github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=
 github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
 github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ=
 github.com/hashicorp/go-hclog v1.2.0 h1:La19f8d7WIlm4ogzNHB0JGqs5AUDAZ2UfCY4sJXcJdM=
-github.com/hashicorp/go-hclog v1.2.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
 github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
-github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
 github.com/hashicorp/go-retryablehttp v0.7.5 h1:bJj+Pj19UZMIweq/iie+1u5YCdGrnxCT9yvm0e+Nd5M=
 github.com/hashicorp/go-retryablehttp v0.7.5/go.mod h1:Jy/gPYAdjqffZ/yFGCFV2doI5wjtH1ewM9u8iYVjtX8=
 github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc=
@@ -116,6 +119,8 @@ github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9Y
 github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
 github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8=
 github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
+github.com/josharian/native v1.1.0 h1:uuaP0hAbW7Y4l0ZRQ6C9zfb7Mg1mbFKry/xzDAfmtLA=
+github.com/josharian/native v1.1.0/go.mod h1:7X/raswPFr05uY3HiLlYeyQntB6OO7E/d2Cu7qoaN2w=
 github.com/json-iterator/go v1.1.5/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
@@ -127,11 +132,13 @@ github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 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.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40=
-github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
 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/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mdlayher/netlink v1.7.2 h1:/UtM3ofJap7Vl4QWCPDGXY8d3GIY2UGSDbK+QWmY8/g=
+github.com/mdlayher/netlink v1.7.2/go.mod h1:xraEF7uJbxLhc5fpHL4cPe221LI2bdttWlU+ZGLfQSw=
+github.com/mdlayher/socket v0.4.1 h1:eM9y2/jlbs1M615oshPQOHZzj6R6wMT7bX5NPiQvn2U=
+github.com/mdlayher/socket v0.4.1/go.mod h1:cAqeGjoufqdxWkD7DkpyS+wcefOtmu5OQ8KuoJGIReA=
 github.com/miekg/dns v1.1.58 h1:ca2Hdkz+cDg/7eNF6V56jjzuZ4aCAE+DbVkILdQWG/4=
 github.com/miekg/dns v1.1.58/go.mod h1:Ypv+3b/KadlvW9vJfXOTf300O4UqaHFzFCuHz+rPkBY=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@@ -148,11 +155,15 @@ github.com/pkg/sftp v1.13.4 h1:Lb0RYJCmgUcBgZosfoi9Y9sbl6+LJgOIgk/2Y4YjMFg=
 github.com/pkg/sftp v1.13.4/go.mod h1:LzqnAvaD5TWeNBsZpfKxSYn1MbjWwOsCIAFFJbpIsK8=
 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/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw=
+github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rogpeppe/go-charset v0.0.0-20180617210344-2471d30d28b4/go.mod h1:qgYeAmZ5ZIpBWTGllZSQnw97Dj+woV0toclVaRGI8pc=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/shirou/gopsutil/v4 v4.24.10 h1:7VOzPtfw/5YDU+jLEoBwXwxJbQetULywoSV4RYY7HkM=
+github.com/shirou/gopsutil/v4 v4.24.10/go.mod h1:s4D/wg+ag4rG0WO7AiTj2BeYCRhym0vM7DHbZRxnIT8=
 github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
 github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
@@ -161,8 +172,7 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common v1.0.490 h1:mmz27tVi2r70JYnm5y0Zk8w0Qzsx+vfUw3oqSyrEfP8=
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common v1.0.490/go.mod h1:7sCQWVkxcsR38nffDW057DRGk8mUjK1Ing/EFOK8s8Y=
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/dnspod v1.0.490 h1:g9SWTaTy/rEuhMErC2jWq9Qt5ci+jBYSvXnJsLq4adg=
@@ -172,7 +182,10 @@ github.com/things-go/go-socks5 v0.0.5/go.mod h1:mtzInf8v5xmsBpHZVbIw2YQYhc4K0jRw
 github.com/vbauerster/mpb/v8 v8.8.3 h1:dTOByGoqwaTJYPubhVz3lO5O6MK553XVgUo33LdnNsQ=
 github.com/vbauerster/mpb/v8 v8.8.3/go.mod h1:JfCCrtcMsJwP6ZwMn9e5LMnNyp3TVNpUWWkN+nd4EWk=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
+github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220313003712-b769efc7c000/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
@@ -184,12 +197,15 @@ golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw=
 golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
 golang.org/x/image v0.6.0 h1:bR8b5okrPI3g/gyZakLZHeWxAR8Dn5CyxXv1hLH5g/4=
 golang.org/x/image v0.6.0/go.mod h1:MXLdDR43H7cDJq5GEGXEVeeNhPgi+YYEQ2pC1byI1x0=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
 golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
@@ -211,7 +227,10 @@ golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
 golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -225,8 +244,9 @@ golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.23.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg=
 golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
+golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
@@ -254,12 +274,14 @@ golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
 golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
 golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg=
 golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -268,7 +290,6 @@ gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
 gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

httpserver/server.go

@@ -1,6 +1,7 @@
 package httpserver
 
 import (
+	"b612.me/apps/b612/version"
 	"b612.me/starcrypto"
 	"b612.me/starlog"
 	"b612.me/starnet"
@@ -24,7 +25,7 @@ import (
 	"time"
 )
 
-var version = "2.1.0.b11"
+var ver = version.Version
 
 type HttpServerCfgs func(cfg *HttpServerCfg)
 
@@ -320,7 +321,7 @@ func (h *HttpServer) Listen(w http.ResponseWriter, r *http.Request) {
 	log.SetShowFuncName(false)
 	log.SetShowOriginFile(false)
 	w.Header().Set("X-Powered-By", "B612.ME")
-	w.Header().Set("Server", "B612/"+version)
+	w.Header().Set("Server", "B612/"+ver)
 	if !h.BasicAuth(log, w, r) {
 		return
 	}
@@ -617,7 +618,7 @@ func (h *HttpServer) getFolder(log *starlog.StarLogger, w http.ResponseWriter, r
 	}
 	err = tmpt.Execute(w, map[string]interface{}{
 		"IdxTitle":    r.URL.Path,
-		"Version":     version,
+		"Version":     ver,
 		"Idx":         "Index of " + r.URL.Path,
 		"Upload":      template.HTML(upload),
 		"Data":        template.JS(jData),

main.go

@@ -29,9 +29,12 @@ import (
 	"b612.me/apps/b612/smtpserver"
 	"b612.me/apps/b612/socks5"
 	"b612.me/apps/b612/split"
+	"b612.me/apps/b612/tcm"
 	"b612.me/apps/b612/tcping"
+	"b612.me/apps/b612/tcpkill"
 	"b612.me/apps/b612/tls"
 	"b612.me/apps/b612/uac"
+	"b612.me/apps/b612/version"
 	"b612.me/apps/b612/vic"
 	"b612.me/apps/b612/whois"
 	"b612.me/stario"
@@ -42,7 +45,7 @@ import (
 
 var cmdRoot = &cobra.Command{
 	Use:     "b612",
-	Version: "2.1.0.beta.13",
+	Version: version.Version,
 }
 
 func init() {
@@ -51,7 +54,7 @@ func init() {
 		base64.Cmd, base85.Cmd, base91.Cmd, attach.Cmd, detach.Cmd, df.Cmd, dfinder.Cmd,
 		ftp.Cmd, generate.Cmd, hash.Cmd, image.Cmd, merge.Cmd, search.Cmd, split.Cmd, vic.Cmd,
 		calc.Cmd, net.Cmd, rmt.Cmds, rmt.Cmdc, keygen.Cmd, dns.Cmd, whois.Cmd, socks5.Cmd, httproxy.Cmd, smtpserver.Cmd, smtpclient.Cmd,
-		cert.Cmd, aes.Cmd, tls.Cmd, mget.Cmd)
+		cert.Cmd, aes.Cmd, tls.Cmd, mget.Cmd, tcpkill.Cmd, tcm.Cmd)
 }
 
 func main() {

mget/wget.go

@@ -223,10 +223,10 @@ func (w *Mget) Run() error {
 	go w.Process()
 	w.wg.Wait()
 	time.Sleep(2 * time.Microsecond)
-	exitFn := sync.OnceFunc(w.fn)
+	var once sync.Once
 	for {
 		if w.writeEnable {
-			exitFn()
+			once.Do(w.fn)
 			time.Sleep(time.Millisecond * 50)
 			continue
 		}
@@ -236,7 +236,7 @@ func (w *Mget) Run() error {
 		}
 		break
 	}
-	exitFn()
+	once.Do(w.fn)
 	stario.WaitUntilTimeout(time.Second*2,
 		func(c chan struct{}) error {
 			for {

net/cmd.go

@@ -2,6 +2,9 @@ package net
 
 import (
 	"b612.me/apps/b612/netforward"
+	"b612.me/apps/b612/tcm"
+	"b612.me/apps/b612/tcping"
+	"b612.me/apps/b612/tcpkill"
 	"b612.me/starlog"
 	"fmt"
 	"github.com/spf13/cobra"
@@ -103,6 +106,7 @@ func init() {
 	CmdScanPort.Flags().IntVarP(&scanport.Retry, "retry", "r", 2, "重试次数")
 	Cmd.AddCommand(CmdScanPort)
 
+	Cmd.AddCommand(tcpkill.Cmd, tcping.Cmd, tcm.Cmd)
 }
 
 var CmdNatPClient = &cobra.Command{

net/scanip.go

@@ -255,8 +255,10 @@ func (s *ScanIP) TCP(port int) error {
 					Timeout:   time.Duration(s.Timeout) * time.Millisecond,
 					Control:   netforward.ControlSetReUseAddr,
 				}
-				_, err := dialer.Dial("tcp", fmt.Sprintf("%s:%d", ip, port))
+				conn, err := dialer.Dial("tcp", fmt.Sprintf("%s:%d", ip, port))
 				if err == nil {
+					conn.(*net.TCPConn).SetLinger(0)
+					conn.Close()
 					atomic.AddInt32(&count, 1)
 					if s.WithHostname {
 						hostname, err := net.LookupAddr(ip)

net/setcpinfo_darwin.go

@@ -3,6 +3,7 @@
 package net
 
 import (
+	"golang.org/x/sys/unix"
 	"net"
 	"syscall"
 )
@@ -33,3 +34,25 @@ func SetTcpInfo(conn *net.TCPConn, usingKeepAlive bool, keepAliveIdel, keepAlive
 	}
 	return err
 }
+
+func SetReUseAddr(fd uintptr) {
+	syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
+	syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, unix.SO_REUSEPORT, 1)
+}
+
+func ControlSetReUseAddr(network, address string, c syscall.RawConn) (err error) {
+	if err := c.Control(func(fd uintptr) {
+		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1)
+		if err != nil {
+			return
+		}
+
+		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1)
+		if err != nil {
+			return
+		}
+	}); err != nil {
+		return err
+	}
+	return err
+}

net/setcpinfo_linux.go

@@ -3,6 +3,7 @@
 package net
 
 import (
+	"golang.org/x/sys/unix"
 	"net"
 	"syscall"
 )
@@ -37,3 +38,25 @@ func SetTcpInfo(conn *net.TCPConn, usingKeepAlive bool, keepAliveIdel, keepAlive
 	}
 	return err
 }
+
+func SetReUseAddr(fd uintptr) {
+	syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
+	syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, unix.SO_REUSEPORT, 1)
+}
+
+func ControlSetReUseAddr(network, address string, c syscall.RawConn) (err error) {
+	if err := c.Control(func(fd uintptr) {
+		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1)
+		if err != nil {
+			return
+		}
+
+		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1)
+		if err != nil {
+			return
+		}
+	}); err != nil {
+		return err
+	}
+	return err
+}

net/setcpinfo_windows.go

@@ -11,6 +11,9 @@ import (
 )
 
 func SetTcpInfo(conn *net.TCPConn, usingKeepAlive bool, keepAliveIdel, keepAlivePeriod, keepAliveCount, userTimeout int) error {
+	//windows上，这两个值是毫秒，linux上则是秒
+	keepAlivePeriod *= 1000
+	keepAliveIdel *= 1000
 	if usingKeepAlive {
 		rawConn, err := conn.SyscallConn()
 		if err != nil {
@@ -31,3 +34,16 @@ func SetTcpInfo(conn *net.TCPConn, usingKeepAlive bool, keepAliveIdel, keepAlive
 	}
 	return conn.SetKeepAlive(false)
 }
+
+func SetReUseAddr(fd uintptr) {
+	syscall.SetsockoptInt(syscall.Handle(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
+}
+
+func ControlSetReUseAddr(network, address string, c syscall.RawConn) (err error) {
+	if err := c.Control(func(fd uintptr) {
+		err = syscall.SetsockoptInt(syscall.Handle(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
+	}); err != nil {
+		return err
+	}
+	return
+}

net/tcpclient.go

@@ -15,12 +15,14 @@ import (
 )
 
 type TcpClient struct {
+	DialTimeout     int
 	LocalAddr       string
 	RemoteAddr      string
 	UsingKeepAlive  bool
 	KeepAlivePeriod int
 	KeepAliveIdel   int
 	KeepAliveCount  int
+	UseLinger       int
 	Interactive     bool
 	UserTimeout     int
 	ShowRecv        bool
@@ -155,17 +157,17 @@ func (s *TcpClient) Run() error {
 			return fmt.Errorf("ResolveTCPAddr error: %w", err)
 		}
 	}
-	remoteAddr, err := net.ResolveTCPAddr("tcp", s.RemoteAddr)
+	dialer := net.Dialer{
-	if err != nil {
+		LocalAddr: localAddr,
-		starlog.Errorln("ResolveTCPAddr error:", err)
+		Timeout:   time.Duration(s.DialTimeout) * time.Second,
-		return fmt.Errorf("ResolveTCPAddr error: %w", err)
+		Control:   ControlSetReUseAddr,
 	}
-
+	tcpConn, err := dialer.Dial("tcp", s.RemoteAddr)
-	conn, err := net.DialTCP("tcp", localAddr, remoteAddr)
 	if err != nil {
 		starlog.Errorln("Dial TCP error:", err)
 		return fmt.Errorf("Dial TCP error: %w", err)
 	}
+	conn := tcpConn.(*net.TCPConn)
 	starlog.Infof("Connected to %s LocalAddr: %s\n", conn.RemoteAddr().String(), conn.LocalAddr().String())
 	if s.Interactive {
 		go s.handleInteractive()
@@ -200,6 +202,9 @@ func (s *TcpClient) handleConn(conn *TcpConn) {
 		conn.Close()
 		return
 	}
+	if s.UseLinger >= 0 {
+		conn.SetLinger(s.UseLinger)
+	}
 	log.Infof("SetKeepAlive success for %s\n", conn.RemoteAddr().String())
 	log.Infof("KeepAlivePeriod: %d, KeepAliveIdel: %d, KeepAliveCount: %d, UserTimeout: %d\n", s.KeepAlivePeriod, s.KeepAliveIdel, s.KeepAliveCount, s.UserTimeout)
 	if runtime.GOOS != "linux" {

net/tcpcmd.go

@@ -25,6 +25,7 @@ func init() {
 	CmdTcps.Flags().BoolVarP(&tcps.ShowAsHex, "show-hex", "H", false, "显示十六进制")
 	CmdTcps.Flags().StringVarP(&tcps.SaveToFolder, "save", "s", "", "保存到文件夹")
 	CmdTcps.Flags().StringVarP(&tcps.LogPath, "log", "L", "", "日志文件路径")
+	CmdTcps.Flags().IntVarP(&tcpc.UseLinger, "linger", "g", -1, "Linger时间（秒）")
 	Cmd.AddCommand(CmdTcps)
 
 	CmdTcpc.Flags().StringVarP(&tcpc.LocalAddr, "local", "l", "", "本地地址")
@@ -38,6 +39,8 @@ func init() {
 	CmdTcpc.Flags().BoolVarP(&tcpc.ShowAsHex, "show-hex", "H", false, "显示十六进制")
 	CmdTcpc.Flags().StringVarP(&tcpc.SaveToFolder, "save", "s", "", "保存到文件夹")
 	CmdTcpc.Flags().StringVarP(&tcpc.LogPath, "log", "L", "", "日志文件路径")
+	CmdTcpc.Flags().IntVarP(&tcpc.DialTimeout, "dial-timeout", "t", 5, "连接超时时间（秒）")
+	CmdTcpc.Flags().IntVarP(&tcpc.UseLinger, "linger", "g", -1, "Linger时间（秒）")
 
 	Cmd.AddCommand(CmdTcpc)
 }

net/tcpserver.go

@@ -26,6 +26,7 @@ type TcpServer struct {
 	KeepAlivePeriod int
 	KeepAliveIdel   int
 	KeepAliveCount  int
+	UseLinger       int
 	sync.Mutex
 	Clients      map[string]*TcpConn
 	Interactive  bool
@@ -233,6 +234,9 @@ func (s *TcpServer) handleConn(conn *TcpConn) {
 		conn.Close()
 		return
 	}
+	if s.UseLinger >= 0 {
+		conn.SetLinger(s.UseLinger)
+	}
 	log.Infof("SetKeepAlive success for %s\n", conn.RemoteAddr().String())
 	log.Infof("KeepAlivePeriod: %d, KeepAliveIdel: %d, KeepAliveCount: %d, UserTimeout: %d\n", s.KeepAlivePeriod, s.KeepAliveIdel, s.KeepAliveCount, s.UserTimeout)
 	if runtime.GOOS != "linux" {

netforward/setcpinfo_windows.go

@@ -11,6 +11,9 @@ import (
 )
 
 func SetTcpInfo(conn *net.TCPConn, usingKeepAlive bool, keepAliveIdel, keepAlivePeriod, keepAliveCount, userTimeout int) error {
+	//windows上，这两个值是毫秒，linux上则是秒
+	keepAlivePeriod *= 1000
+	keepAliveIdel *= 1000
 	if usingKeepAlive {
 		rawConn, err := conn.SyscallConn()
 		if err != nil {

tcm/cmd_unix.go

@@ -0,0 +1,38 @@
+//go:build !windows
+
+package tcm
+
+import "github.com/spf13/cobra"
+
+var nf = NewNfCap()
+
+var Cmd = &cobra.Command{
+	Use:   "tcm",
+	Short: "TCP连接监视工具",
+	Run: func(cmd *cobra.Command, args []string) {
+		nf.Run()
+	},
+}
+
+func init() {
+	Cmd.Flags().IntVarP(&nf.monitorPort, "port", "p", 0, "nft转发端口地址，如果启用此参数，将会自动设置iptables，需要安装iptables")
+	Cmd.Flags().StringSliceVarP(&nf.target, "target", "t", []string{}, "监控的ip地址，可多个，本工具各类延迟等tcp操作仅对此类ip生效")
+	Cmd.Flags().StringSliceVarP(&nf.targetCmd, "cmd", "c", []string{}, "触发报文drop的关键词，utf8格式，如:show variables")
+	Cmd.Flags().BoolVarP(&nf.targetAsHex, "cmd-as-hex", "x", false, "启用此选项，cmd选项请传入hex字符，而不是utf-8")
+	Cmd.Flags().StringVarP(&nf.saveFile, "save", "w", "", "保存文件路径，将会保存所有报文到此文件")
+	Cmd.Flags().BoolVarP(&nf.interactive, "interactive", "i", false, "启用交互模式，可输入命令：allow <ip>,drop <ip>,delay <ms>,loss <number%>")
+	Cmd.Flags().BoolVarP(&nf.showAll, "display-all", "D", false, "显示所有报文，包括非target对象")
+	Cmd.Flags().BoolVarP(&nf.showAsHex, "as-hex", "a", false, "显示报文的hex内容")
+	Cmd.Flags().BoolVarP(&nf.showPayload, "show-payload", "S", false, "显示报文的payload")
+	Cmd.Flags().IntVarP(&nf.maxShowPayloadSize, "payload-maxlen", "m", 200, "显示payload的最大长度")
+	Cmd.Flags().BoolVarP(&nf.noShowMode, "no-show", "N", false, "不显示任何tcp报文，只统计数量")
+	Cmd.Flags().Float64VarP(&nf.loss, "loss", "l", 0, "丢包率，0-100之间，如10表示10%丢包")
+	Cmd.Flags().IntVarP(&nf.delay, "delay", "d", 0, "延迟时间，单位ms")
+	Cmd.Flags().IntVarP(&nf.packetDelay, "packet-delay-num", "n", 0, "触发封禁关键词后，延迟n个包再封禁")
+	Cmd.Flags().BoolVarP(&nf.useRST, "rst", "r", false, "触发封禁关键词后，同步发送RST报文")
+	Cmd.Flags().StringVarP(&nf.rstMode, "rstmode", "R", "reverse", "RST报文发送模式，可选值：both,target,reverse")
+	Cmd.Flags().BoolVarP(&nf.fastMode, "fastmode", "f", false, "快速模式，仅在模拟延迟或丢包时使用")
+	Cmd.Flags().IntVarP(&nf.NFQNums, "nfqueue-num", "q", 2, "nfqueue队列号")
+	Cmd.Flags().BoolVarP(&nf.allowRandomAck, "random-ack", "A", false, "允许并行乱序处理报文，如果需要模拟延迟，此选项需开启，但封禁功能可能受到乱序影响")
+	Cmd.Flags().BoolVarP(&nf.onlyDropblackwordPacket, "only-drop-blackword-packet", "o", false, "只封禁包含关键词的报文,此模式下，packetDelay会失效")
+}

tcm/cmd_winarm64.go

@@ -0,0 +1,16 @@
+//go:build windows && arm64
+
+package tcm
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+)
+
+var Cmd = &cobra.Command{
+	Use:   "tcm",
+	Short: "TCP连接监视工具",
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Println("windows on arm is not supported yet")
+	},
+}

tcm/cmd_windows.go

@@ -0,0 +1,33 @@
+//go:build windows && !arm64
+
+package tcm
+
+import "github.com/spf13/cobra"
+
+var nf = NewLibpcap()
+var Cmd = &cobra.Command{
+	Use:   "tcm",
+	Short: "TCP连接监视工具",
+	Run: func(cmd *cobra.Command, args []string) {
+		nf.Run()
+	},
+}
+
+func init() {
+	Cmd.Flags().StringSliceVarP(&nf.target, "target", "t", []string{}, "监控的ip地址，可多个，本工具各类延迟等tcp操作仅对此类ip生效")
+	Cmd.Flags().StringSliceVarP(&nf.targetCmd, "cmd", "c", []string{}, "触发报文drop的关键词，utf8格式，如:show variables")
+	Cmd.Flags().BoolVarP(&nf.targetAsHex, "cmd-as-hex", "x", false, "启用此选项，cmd选项请传入hex字符，而不是utf-8")
+	Cmd.Flags().StringVarP(&nf.saveFile, "save", "w", "", "保存文件路径，将会保存所有报文到此文件")
+	//Cmd.Flags().BoolVarP(&nf.interactive, "interactive", "i", false, "启用交互模式，可输入命令：allow <ip>,drop <ip>,delay <ms>,loss <number%>")
+	Cmd.Flags().BoolVarP(&nf.showAll, "display-all", "D", false, "显示所有报文，包括非target对象")
+	Cmd.Flags().BoolVarP(&nf.showAsHex, "as-hex", "a", false, "显示报文的hex内容")
+	Cmd.Flags().BoolVarP(&nf.showPayload, "show-payload", "S", false, "显示报文的payload")
+	Cmd.Flags().IntVarP(&nf.maxShowPayloadSize, "payload-maxlen", "m", 200, "显示payload的最大长度")
+	Cmd.Flags().BoolVarP(&nf.noShowMode, "no-show", "N", false, "不显示任何tcp报文，只统计数量")
+	Cmd.Flags().BoolVarP(&nf.useRST, "rst", "r", false, "触发封禁关键词后，同步发送RST报文")
+	Cmd.Flags().StringVarP(&nf.rstMode, "rstmode", "R", "reverse", "RST报文发送模式，可选值：both,target,reverse")
+	Cmd.Flags().StringVarP(&nf.eth, "eth", "e", "", "监听网卡名，如eth0")
+	Cmd.Flags().StringVarP(&nf.bpf, "bpf", "b", "tcp", "BPF过滤,如tcp port 80")
+	Cmd.Flags().StringVarP(&nf.host, "host", "i", "", "监听主机名，如127.0.0.1")
+
+}

tcm/tcpmonitor_unix.go

@@ -0,0 +1,679 @@
+//go:build !windows
+
+package tcm
+
+import (
+	"b612.me/bcap"
+	"b612.me/bcap/nfq"
+	"b612.me/stario"
+	"b612.me/starlog"
+	"context"
+	"encoding/hex"
+	"fmt"
+	"github.com/florianl/go-nfqueue/v2"
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/google/gopacket/pcapgo"
+	"math/rand"
+	"net"
+	"os"
+	"os/exec"
+	"os/signal"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+)
+
+type NfCap struct {
+	count uint64
+	// 按连接数最后一个历史报文
+	cap *bcap.Packets
+	// 监控目标ip地址列表
+	target []string
+	// 将军，下达命令吧！
+	// 监控命令列表
+	targetCmd   []string
+	targetAsHex bool
+	//保存为pcap格式的数据文件
+	saveFile string
+	// 写缓存
+	packetCache chan gopacket.Packet
+	//保存封禁的map
+	blockMap sync.Map
+	//交互模式
+	interactive bool
+	//展示所有报文信息，包括未在追踪列表的
+	showAll bool
+	//展示payload报文（utf-8直接输出）
+	showPayload bool
+	//payload展示为hex
+	showAsHex bool
+	//payload允许展示的最大字符
+	maxShowPayloadSize int
+	//不展示任何信息
+	noShowMode bool
+	// 全链路丢包率，百分比
+	loss float64
+	// 报文延迟抵达时间，毫秒
+	delay int
+	// 触发封禁词后，再过N个包再封禁
+	packetDelay int
+	// 触发封禁词后，使用RST重置链路
+	useRST bool
+	// RST模式，target=目标端单向RST，reverse=对端反向RST，both=双向RST
+	rstMode                 string
+	fastMode                bool //自探测
+	printColor              []*starlog.Color
+	logCache                chan loged
+	monitorPort             int
+	cache                   []string
+	NFQNums                 int
+	ctx                     context.Context
+	fn                      context.CancelFunc
+	requests                chan *handler
+	allowRandomAck          bool
+	onlyDropblackwordPacket bool
+}
+
+type loged struct {
+	str        string
+	stateLevel int
+	logLevel   string
+}
+
+func (n *NfCap) inactve() {
+	for {
+		f := strings.Fields(stario.MessageBox("", "").MustString())
+		if len(f) < 2 {
+			continue
+		}
+		switch f[0] {
+		case "allow":
+			for _, v := range f[1:] {
+				n.blockMap.Delete(v)
+				starlog.Infof("允许%s报文\n", v)
+			}
+		case "drop":
+			for _, v := range f[1:] {
+				n.blockMap.Store(v, true)
+				starlog.Infof("封禁%s报文\n", v)
+			}
+		case "delay":
+			tmp, err := strconv.Atoi(f[1])
+			if err != nil {
+				starlog.Errorln("输入延迟无效：%v\n", err)
+				continue
+			}
+			n.delay = tmp
+			starlog.Infof("延迟生效：%v ms\n", n.delay)
+		case "loss":
+			tmp, err := strconv.ParseFloat(f[1], 64)
+			if err != nil {
+				starlog.Errorln("输入丢包百分比无效：%v\n", err)
+				continue
+			}
+			n.loss = tmp
+			starlog.Infof("丢包百分比生效：%v ms\n", n.loss)
+		}
+	}
+}
+
+func (t *NfCap) doIptables() error {
+	if t.monitorPort != 0 {
+		if _, err := exec.Command("iptables", "-t", "raw", "-A", "PREROUTING", "-p", "tcp", "--dport", strconv.Itoa(t.monitorPort), "-j", "NFQUEUE", "--queue-num", strconv.Itoa(t.NFQNums)).CombinedOutput(); err != nil {
+			return err
+		}
+		t.cache = append(t.cache, "-t raw -D PREROUTING -p tcp --dport "+strconv.Itoa(t.monitorPort)+" -j NFQUEUE --queue-num "+strconv.Itoa(t.NFQNums))
+		if _, err := exec.Command("iptables", "-t", "raw", "-A", "OUTPUT", "-p", "tcp", "--sport", strconv.Itoa(t.monitorPort), "-j", "NFQUEUE", "--queue-num", strconv.Itoa(t.NFQNums)).CombinedOutput(); err != nil {
+			return err
+		}
+		t.cache = append(t.cache, "-t raw -D OUTPUT -p tcp --sport "+strconv.Itoa(t.monitorPort)+" -j NFQUEUE --queue-num "+strconv.Itoa(t.NFQNums))
+		if _, err := exec.Command("iptables", "-t", "raw", "-A", "PREROUTING", "-p", "tcp", "--sport", strconv.Itoa(t.monitorPort), "-j", "NFQUEUE", "--queue-num", strconv.Itoa(t.NFQNums)).CombinedOutput(); err != nil {
+			return err
+		}
+		t.cache = append(t.cache, "-t raw -D PREROUTING -p tcp --sport "+strconv.Itoa(t.monitorPort)+" -j NFQUEUE --queue-num "+strconv.Itoa(t.NFQNums))
+		if _, err := exec.Command("iptables", "-t", "raw", "-A", "OUTPUT", "-p", "tcp", "--dport", strconv.Itoa(t.monitorPort), "-j", "NFQUEUE", "--queue-num", strconv.Itoa(t.NFQNums)).CombinedOutput(); err != nil {
+			return err
+		}
+		t.cache = append(t.cache, "-t raw -D OUTPUT -p tcp --dport "+strconv.Itoa(t.monitorPort)+" -j NFQUEUE --queue-num "+strconv.Itoa(t.NFQNums))
+
+	}
+	return nil
+}
+
+func (t *NfCap) undoIptables() {
+	for _, cmd := range t.cache {
+		exec.Command("iptables", strings.Fields(cmd)...).CombinedOutput()
+	}
+}
+
+func (t *NfCap) Run() error {
+	stopSignal := make(chan os.Signal)
+	starlog.Noticef("Starting nfqueue capture\n")
+	nf := nfq.NewNfQueue(t.ctx, uint16(t.NFQNums), 65535)
+	nf.SetRecall(t.handleRoute)
+	if t.targetAsHex {
+		for k, v := range t.targetCmd {
+			tmp, _ := hex.DecodeString(v)
+			t.targetCmd[k] = string(tmp)
+		}
+	}
+	go func() {
+		if err := nf.Run(); err != nil {
+			starlog.Errorln(err)
+			stopSignal <- syscall.SIGKILL
+		}
+	}()
+	if t.saveFile != "" {
+		f, err := os.Create(t.saveFile)
+		if err != nil {
+			starlog.Errorln("创建写入文件失败", err)
+			os.Exit(4)
+		}
+		defer f.Close()
+		go t.pcapWriter(t.ctx, f)
+	}
+	if t.monitorPort != 0 {
+		if _, err := exec.Command("iptables", "-V").CombinedOutput(); err != nil {
+			starlog.Warningln("iptables not found, cannot auto set iptables")
+			return fmt.Errorf("iptables not found")
+		}
+		defer t.undoIptables()
+		if err := t.doIptables(); err != nil {
+			starlog.Errorf("Failed to set iptables:%v\n", err)
+			return err
+		}
+		starlog.Infof("Set iptables success\n")
+	}
+	signal.Notify(stopSignal, syscall.SIGINT, syscall.SIGTERM, syscall.SIGKILL)
+	go t.handleNfResult()
+	go t.logPrint(t.ctx)
+	select {
+	//todo need nf.Stop()
+	case <-stopSignal:
+		starlog.Warningf("Received stop signal\n")
+
+	case <-t.ctx.Done():
+		starlog.Infoln("TCPMonitor Task Finished")
+
+	}
+	return nil
+
+}
+
+func NewNfCap() *NfCap {
+	var nf = new(NfCap)
+	nf.packetCache = make(chan gopacket.Packet, 2048)
+	nf.logCache = make(chan loged, 2048)
+	nf.printColor = []*starlog.Color{
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+		starlog.NewColor(starlog.FgHiCyan),                //1=tcp_connect_1,
+		starlog.NewColor(starlog.FgHiCyan),                //2=tcp_connect_2,
+		starlog.NewColor(starlog.FgHiCyan),                //3=tcp_connect_3,
+		starlog.NewColor(starlog.FgCyan),                  //4=tcp_bye_bye
+		starlog.NewColor(starlog.FgCyan),                  //5=tcp_bye_bye
+		starlog.NewColor(starlog.FgCyan),                  //6=tcp_bye_bye
+		starlog.NewColor(starlog.FgCyan),                  //7=tcp_bye_bye
+		starlog.NewColor(starlog.FgCyan),                  //8=tcp_bye_bye
+		starlog.NewColor(starlog.FgGreen),                 //9=tcp_ok
+		starlog.NewColor(starlog.BgRed, starlog.FgYellow), //10=tcp_retrans
+		starlog.NewColor(starlog.FgHiMagenta),             //ece
+		starlog.NewColor(starlog.FgHiMagenta),             //cwr
+		starlog.NewColor(starlog.FgRed),                   //rst
+		starlog.NewColor(starlog.FgHiGreen),               //keepalive
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+		starlog.NewColor(starlog.FgWhite),                 //20=udp
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+	}
+	nf.cap = bcap.NewPackets()
+	nf.ctx, nf.fn = context.WithCancel(context.Background())
+	nf.requests = make(chan *handler, 2048)
+	return nf
+}
+func (t *NfCap) handleNfResult() {
+	for {
+		select {
+		case <-t.ctx.Done():
+			return
+		case info := <-t.requests:
+			if info == nil {
+				continue
+			}
+			if t.allowRandomAck {
+				go info.p.SetVerdict(info.id, <-info.fin)
+				continue
+			}
+			info.p.SetVerdict(info.id, <-info.fin)
+		}
+	}
+}
+
+func (t *NfCap) handleRoute(id uint32, q *nfqueue.Nfqueue, p nfq.Packet) {
+	if t.requests == nil {
+		q.SetVerdict(id, nfqueue.NfAccept)
+		return
+	}
+	info, err := t.cap.ParsePacket(p.Packet)
+	if err != nil {
+		q.SetVerdict(id, nfqueue.NfAccept)
+		return
+	}
+	fin := make(chan int)
+	t.requests <- &handler{
+		id:     id,
+		p:      q,
+		packet: p.Packet,
+		attr:   p.Attr,
+		fin:    fin,
+	}
+	go func() {
+		fin <- t.handlePacket(info, p)
+	}()
+}
+
+type handler struct {
+	id     uint32
+	p      *nfqueue.Nfqueue
+	packet gopacket.Packet
+	attr   nfqueue.Attribute
+	fin    chan int
+}
+
+func (n *NfCap) logPrint(ctx context.Context) {
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case l := <-n.logCache:
+			if n.noShowMode {
+				fmt.Printf("已捕获报文数量:%v个\r", n.count)
+				continue
+			}
+			switch l.logLevel {
+			case "info":
+				starlog.Info(l.str)
+			case "notice":
+				starlog.Notice(l.str)
+			case "warning":
+				starlog.Warning(l.str)
+			case "error":
+				starlog.Error(l.str)
+			case "critical":
+				starlog.Critical(l.str)
+			case "debug":
+				starlog.Debug(l.str)
+			case "payload":
+				fmt.Println(l.str)
+			default:
+				n.printColor[l.stateLevel].Print(l.str)
+			}
+		}
+	}
+}
+
+func (n *NfCap) ipInRange(ip string) bool {
+	if len(n.target) == 0 {
+		return false
+	}
+	for _, v := range n.target {
+		if v == ip {
+			return true
+		}
+	}
+	return false
+}
+
+func (n *NfCap) strInRange(str string) bool {
+	if len(n.targetCmd) == 0 {
+		return false
+	}
+	for _, v := range n.targetCmd {
+		if v == "" {
+			continue
+		}
+		if strings.Contains(str, v) {
+			return true
+		}
+	}
+	return false
+}
+
+func (n *NfCap) handlePacket(info bcap.PacketInfo, nfp nfq.Packet) int {
+	p := nfp.Packet
+	n.count++
+	if n.saveFile != "" {
+		n.packetCache <- p
+	}
+	var layer gopacket.Layer
+	for _, layerType := range []gopacket.LayerType{
+		layers.LayerTypeTCP, layers.LayerTypeUDP, layers.LayerTypeICMPv4, layers.LayerTypeICMPv6,
+		layers.LayerTypeIPv4, layers.LayerTypeIPv6, layers.LayerTypeARP,
+	} {
+		layer = p.Layer(layerType)
+		if layer == nil {
+			continue
+		}
+		break
+	}
+	if layer == nil {
+		n.logCache <- loged{
+			str:        "无法定义layer类型\n",
+			stateLevel: 0,
+			logLevel:   "error",
+		}
+		return nfqueue.NfAccept
+	}
+	var shouldDisallow bool
+	if n.fastMode {
+		if n.delay > 0 || n.loss > 0 {
+			if n.delay > 0 && (n.ipInRange(info.SrcIP) || n.ipInRange(info.DstIP)) {
+				time.Sleep(time.Millisecond * time.Duration(n.delay))
+			}
+			if n.loss > 0 && (n.ipInRange(info.SrcIP) || n.ipInRange(info.DstIP)) {
+				if rand.Intn(10000) < int(n.loss*100) {
+					shouldDisallow = true
+				}
+			}
+		}
+		if shouldDisallow {
+			return nfqueue.NfDrop
+		}
+		return nfqueue.NfAccept
+	}
+	if n.loss > 0 && (n.ipInRange(info.SrcIP) || n.ipInRange(info.DstIP)) {
+		if rand.Intn(10000) < int(n.loss*100) {
+			shouldDisallow = true
+		}
+	}
+	if n.delay > 0 && (n.ipInRange(info.SrcIP) || n.ipInRange(info.DstIP)) {
+		time.Sleep(time.Millisecond * time.Duration(n.delay))
+	}
+	var dec string
+	switch info.StateDescript() {
+	case 0:
+		dec = "未知状态"
+	case 1:
+		dec = "SYN tcp建立一次握手"
+	case 2:
+		dec = "SYN,ACK tcp建立二次握手"
+	case 3:
+		dec = "ACK tcp建立三次握手"
+	case 4:
+		dec = "FIN tcp断开一次挥手"
+	case 5:
+		dec = "ACK tcp断开二次挥手"
+	case 6:
+		dec = "FIN,ACK tcp断开二次三次挥手"
+	case 7:
+		dec = "FIN tcp断开三次挥手"
+	case 8:
+		dec = "ACK tcp断开四次挥手"
+	case 9:
+		dec = "tcp报文"
+	case 10:
+		dec = "TCP重传"
+	case 11:
+		dec = "TCP ece"
+	case 12:
+		dec = "TCP cwr"
+	case 13:
+		dec = "TCP RST重置"
+	case 14:
+		dec = "TCP Keepalive"
+	}
+	if n.showAll || n.ipInRange(info.SrcIP) || n.ipInRange(info.DstIP) {
+		n.logCache <- loged{
+			str: fmt.Sprintf("%s %v:%v -> %v:%v %s seq=%v ack=%v win=%v len=%v\n", time.Now().Format("2006-01-02 15:04:05.000000"), info.SrcIP, info.SrcPort,
+				info.DstIP, info.DstPort, dec, info.TcpSeq(), info.TcpAck(), info.TcpWindow(), info.TcpPayloads()),
+			stateLevel: int(info.StateDescript()),
+			logLevel:   "",
+		}
+		if n.showPayload {
+			str := string(layer.LayerPayload())
+			if n.maxShowPayloadSize > 0 {
+				if len(str) > n.maxShowPayloadSize {
+					str = str[:n.maxShowPayloadSize]
+				}
+			}
+			if n.showAsHex {
+				str = hex.EncodeToString([]byte(str))
+			}
+			n.logCache <- loged{
+				str:        str,
+				stateLevel: int(info.StateDescript()),
+				logLevel:   "payload",
+			}
+		}
+	}
+	if info.Comment() != "" || n.cap.Key(info.ReverseKey).Comment() != "" {
+		tmp := info.Comment()
+		if tmp == "" {
+			tmp = n.cap.Key(info.ReverseKey).Comment()
+		}
+		pkg, _ := strconv.Atoi(tmp)
+		n.logCache <- loged{
+			str:        fmt.Sprintf("current delay count:%v\n", pkg-1),
+			stateLevel: 0,
+			logLevel:   "warning",
+		}
+		if pkg-1 <= 0 {
+			if n.useRST {
+				RealSendRST(info, n.rstMode, 3)
+			}
+			if n.ipInRange(info.SrcIP) {
+				n.blockMap.Store(info.SrcIP, true)
+			} else {
+				n.blockMap.Store(info.DstIP, true)
+			}
+			n.cap.SetComment(info.Key, "")
+			n.cap.SetComment(info.ReverseKey, "")
+		} else {
+			n.cap.SetComment(info.Key, strconv.Itoa(pkg-1))
+			n.cap.SetComment(info.ReverseKey, strconv.Itoa(pkg-1))
+		}
+	}
+	if len(n.targetCmd) > 0 && (n.ipInRange(info.SrcIP) || n.ipInRange(info.DstIP)) && n.strInRange(string(layer.LayerPayload())) {
+		n.logCache <- loged{
+			str: fmt.Sprintf("%s:%s -> %s:%s ！！Match Keyword,will block！！\n", info.SrcIP, info.SrcPort,
+				info.DstIP, info.DstPort),
+			stateLevel: 0,
+			logLevel:   "warning",
+		}
+		if n.onlyDropblackwordPacket {
+			if n.useRST && info.StateDescript() == 13 {
+				return nfqueue.NfAccept
+			}
+			n.logCache <- loged{
+				str:        fmt.Sprintf("Block TCP %v:%v -> %v:%v,LEN=%d\n", info.SrcIP, info.SrcPort, info.DstIP, info.DstPort, info.TcpPayloads()),
+				stateLevel: 0,
+				logLevel:   "warning",
+			}
+			return nfqueue.NfDrop
+		}
+		if n.packetDelay > 0 && info.Comment() == "" {
+			n.cap.SetComment(info.Key, strconv.Itoa(n.packetDelay))
+			n.cap.SetComment(info.ReverseKey, strconv.Itoa(n.packetDelay))
+		} else {
+			if n.useRST {
+				RealSendRST(info, n.rstMode, 3)
+			}
+			if n.ipInRange(info.SrcIP) {
+				n.blockMap.Store(info.SrcIP, true)
+			} else {
+				n.blockMap.Store(info.DstIP, true)
+			}
+		}
+	}
+
+	_, ok1 := n.blockMap.Load(info.DstIP)
+	_, ok2 := n.blockMap.Load(info.SrcIP)
+	if ok1 || ok2 {
+		if n.useRST && info.StateDescript() == 13 {
+			return nfqueue.NfAccept
+		}
+		n.logCache <- loged{
+			str:        fmt.Sprintf("Block TCP %v:%v -> %v:%v,LEN=%d\n", info.SrcIP, info.SrcPort, info.DstIP, info.DstPort, info.TcpPayloads()),
+			stateLevel: 0,
+			logLevel:   "warning",
+		}
+		return nfqueue.NfDrop
+	}
+	if shouldDisallow {
+		n.logCache <- loged{
+			str:        fmt.Sprintf("Block(loss) TCP %v:%v -> %v:%v,LEN=%d\n", info.SrcIP, info.SrcPort, info.DstIP, info.DstPort, info.TcpPayloads()),
+			stateLevel: 0,
+			logLevel:   "warning",
+		}
+		return nfqueue.NfDrop
+	}
+	return nfqueue.NfAccept
+}
+
+func (n *NfCap) pcapWriter(stopCtx context.Context, fp *os.File) error {
+	w := pcapgo.NewWriter(fp)
+	err := w.WriteFileHeader(65535, layers.LinkTypeRaw)
+	if err != nil {
+		return err
+	}
+	for {
+		select {
+		case <-stopCtx.Done():
+			return nil
+		case p := <-n.packetCache:
+			w.WritePacket(gopacket.CaptureInfo{
+				Timestamp:     time.Now(),
+				CaptureLength: len(p.Data()),
+				Length:        len(p.Data()),
+			}, p.Data())
+		}
+	}
+}
+
+func RealSendRST(info bcap.PacketInfo, target string, number int) {
+	for i := 0; i < number; i++ {
+		if target == "both" || target == "target" {
+			SendRST(info.SrcIP, info.SrcPort, info.DstIP, info.DstPort, info.TcpSeq()+(uint32(i)*uint32(info.TcpWindow())))
+		}
+		if target == "both" || target == "reverse" {
+			SendRST(info.DstIP, info.DstPort, info.SrcIP, info.SrcPort, info.TcpAck()+(uint32(i)*uint32(info.TcpWindow())))
+		}
+	}
+}
+
+func SendRST(srcIP, srcPort, dstIP, dstPort string, seq uint32) error {
+	if net.ParseIP(dstIP).To4() != nil {
+		return sendIPv4(srcIP, srcPort, dstIP, dstPort, seq, false)
+	}
+	return sendIPv6(srcIP, srcPort, dstIP, dstPort, seq, false)
+}
+
+func SendSYN(srcIP, srcPort, dstIP, dstPort string, seq uint32) error {
+	if net.ParseIP(dstIP).To4() != nil {
+		return sendIPv4(srcIP, srcPort, dstIP, dstPort, seq, true)
+	}
+	return sendIPv6(srcIP, srcPort, dstIP, dstPort, seq, true)
+}
+
+func sendIPv4(srcIP, srcPort, dstIP, dstPort string, seq uint32, isSyn bool) error {
+	fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_RAW, syscall.IPPROTO_RAW)
+	if err != nil {
+		return err
+	}
+	defer syscall.Close(fd)
+
+	dstNetIP := net.ParseIP(dstIP)
+	iPv4 := layers.IPv4{
+		SrcIP:    net.ParseIP(srcIP),
+		DstIP:    dstNetIP,
+		Version:  4,
+		TTL:      64,
+		Protocol: layers.IPProtocolTCP,
+	}
+	sPort, err := strconv.Atoi(srcPort)
+	if err != nil {
+		return err
+	}
+	dPort, err := strconv.Atoi(dstPort)
+	if err != nil {
+		return err
+	}
+	tcp := layers.TCP{
+		SrcPort: layers.TCPPort(sPort),
+		DstPort: layers.TCPPort(dPort),
+		Seq:     seq,
+		RST:     !isSyn,
+		SYN:     isSyn,
+	}
+
+	if err = tcp.SetNetworkLayerForChecksum(&iPv4); err != nil {
+		return err
+	}
+	buffer := gopacket.NewSerializeBuffer()
+	options := gopacket.SerializeOptions{
+		FixLengths:       true,
+		ComputeChecksums: true,
+	}
+	if err = gopacket.SerializeLayers(buffer, options, &iPv4, &tcp); err != nil {
+		return err
+	}
+	addr := syscall.SockaddrInet4{
+		Port: dPort,
+		Addr: [4]byte{dstNetIP.To4()[0], dstNetIP.To4()[1], dstNetIP.To4()[2], dstNetIP.To4()[3]},
+	}
+	return syscall.Sendto(fd, buffer.Bytes(), 0, &addr)
+}
+
+func sendIPv6(srcIP, srcPort, dstIP, dstPort string, seq uint32, isSyn bool) error {
+	fd, err := syscall.Socket(syscall.AF_INET6, syscall.SOCK_RAW, syscall.IPPROTO_RAW)
+	if err != nil {
+		return err
+	}
+	defer syscall.Close(fd)
+
+	dstNetIP := net.ParseIP(dstIP)
+	iPv6 := layers.IPv6{
+		SrcIP:      net.ParseIP(srcIP),
+		DstIP:      dstNetIP,
+		Version:    6,
+		NextHeader: layers.IPProtocolTCP,
+		HopLimit:   64,
+	}
+	sPort, err := strconv.Atoi(srcPort)
+	if err != nil {
+		return err
+	}
+	dPort, err := strconv.Atoi(dstPort)
+	if err != nil {
+		return err
+	}
+	tcp := layers.TCP{
+		SrcPort: layers.TCPPort(sPort),
+		DstPort: layers.TCPPort(dPort),
+		Seq:     seq,
+		RST:     !isSyn,
+		SYN:     isSyn,
+	}
+
+	if err := tcp.SetNetworkLayerForChecksum(&iPv6); err != nil {
+		return err
+	}
+	buffer := gopacket.NewSerializeBuffer()
+	options := gopacket.SerializeOptions{
+		FixLengths:       true,
+		ComputeChecksums: true,
+	}
+	if err = gopacket.SerializeLayers(buffer, options, &iPv6, &tcp); err != nil {
+		return err
+	}
+	addr := syscall.SockaddrInet6{
+		Port: dPort,
+		Addr: [16]byte(dstNetIP.To16()),
+	}
+	return syscall.Sendto(fd, buffer.Bytes(), 0, &addr)
+}

tcm/tcpmonitor_windows.go

@@ -0,0 +1,474 @@
+//go:build windows && !arm64
+
+package tcm
+
+import (
+	"b612.me/bcap"
+	"b612.me/bcap/libpcap"
+	"b612.me/starlog"
+	"context"
+	"encoding/hex"
+	"fmt"
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/google/gopacket/pcap"
+	"github.com/google/gopacket/pcapgo"
+	"net"
+	"os"
+	"os/signal"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+)
+
+type Libpcap struct {
+	count uint64
+	// 按连接数最后一个历史报文
+	cap *bcap.Packets
+	// 监控目标ip地址列表
+	target []string
+	// 将军，下达命令吧！
+	// 监控命令列表
+	targetCmd   []string
+	targetAsHex bool
+	//保存为pcap格式的数据文件
+	saveFile string
+	// 写缓存
+	packetCache chan gopacket.Packet
+	//交互模式
+	interactive bool
+	//展示所有报文信息，包括未在追踪列表的
+	showAll bool
+	//展示payload报文（utf-8直接输出）
+	showPayload bool
+	//payload展示为hex
+	showAsHex bool
+	//payload允许展示的最大字符
+	maxShowPayloadSize int
+	//不展示任何信息
+	noShowMode bool
+	// 触发封禁词后，使用RST重置链路
+	useRST bool
+	// RST模式，target=目标端单向RST，reverse=对端反向RST，both=双向RST
+	rstMode    string
+	printColor []*starlog.Color
+	logCache   chan loged
+	ctx        context.Context
+	fn         context.CancelFunc
+	bpf        string
+	eth        string
+	host       string
+	handle     *libpcap.NetCatch
+	blockMap   sync.Map
+}
+
+type loged struct {
+	str        string
+	stateLevel int
+	logLevel   string
+}
+
+func (t *Libpcap) Run() error {
+	var err error
+	stopSignal := make(chan os.Signal)
+	starlog.Noticef("Starting libpcap capture\n")
+	if t.bpf == "" {
+		starlog.Errorln("请输入一个抓包模式")
+		os.Exit(3)
+	}
+	if t.host == "" && t.eth == "" {
+		starlog.Errorln("请输入eth网卡名或host名")
+		ifs, err := libpcap.FindAllDevs()
+		if err == nil {
+			fmt.Println("网卡名如下:\n----------\n")
+			for k, v := range ifs {
+				var ips []string
+				for _, vv := range v.Addresses {
+					ips = append(ips, vv.IP.String())
+				}
+				fmt.Printf("%d.\t%v\t%s\t%v\n", k+1, v.Name, strings.Join(ips, " , "), v.Description)
+			}
+			fmt.Println()
+		}
+		return fmt.Errorf("请输入eth网卡名或host名")
+	}
+	if t.host == "" {
+		t.handle, err = libpcap.NewCatchEth(t.eth, t.bpf)
+	} else {
+		t.handle, err = libpcap.NewCatch(t.host, t.bpf)
+	}
+	if err != nil {
+		starlog.Errorln("failed to listen:", err)
+		return err
+	}
+	t.handle.SetRecall(t.handlePacket)
+	if t.targetAsHex {
+		for k, v := range t.targetCmd {
+			tmp, _ := hex.DecodeString(v)
+			t.targetCmd[k] = string(tmp)
+		}
+	}
+	go func() {
+		if err = t.handle.Run(); err != nil {
+			starlog.Errorln(err)
+			stopSignal <- syscall.SIGKILL
+		}
+	}()
+	if t.saveFile != "" {
+		f, err := os.Create(t.saveFile)
+		if err != nil {
+			starlog.Errorln("创建写入文件失败", err)
+			os.Exit(4)
+		}
+		defer f.Close()
+		go t.pcapWriter(t.ctx, f)
+	}
+	signal.Notify(stopSignal, syscall.SIGINT, syscall.SIGTERM, syscall.SIGKILL)
+	go t.logPrint(t.ctx)
+	select {
+	//todo need nf.Stop()
+	case <-stopSignal:
+		starlog.Warningf("Received stop signal\n")
+
+	case <-t.ctx.Done():
+		starlog.Infoln("TCPMonitor Task Finished")
+
+	}
+	return nil
+
+}
+
+func NewLibpcap() *Libpcap {
+	var nf = new(Libpcap)
+	nf.packetCache = make(chan gopacket.Packet, 2048)
+	nf.logCache = make(chan loged, 2048)
+	nf.printColor = []*starlog.Color{
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+		starlog.NewColor(starlog.FgHiCyan),                //1=tcp_connect_1,
+		starlog.NewColor(starlog.FgHiCyan),                //2=tcp_connect_2,
+		starlog.NewColor(starlog.FgHiCyan),                //3=tcp_connect_3,
+		starlog.NewColor(starlog.FgCyan),                  //4=tcp_bye_bye
+		starlog.NewColor(starlog.FgCyan),                  //5=tcp_bye_bye
+		starlog.NewColor(starlog.FgCyan),                  //6=tcp_bye_bye
+		starlog.NewColor(starlog.FgCyan),                  //7=tcp_bye_bye
+		starlog.NewColor(starlog.FgCyan),                  //8=tcp_bye_bye
+		starlog.NewColor(starlog.FgGreen),                 //9=tcp_ok
+		starlog.NewColor(starlog.BgRed, starlog.FgYellow), //10=tcp_retrans
+		starlog.NewColor(starlog.FgHiMagenta),             //ece
+		starlog.NewColor(starlog.FgHiMagenta),             //cwr
+		starlog.NewColor(starlog.FgRed),                   //rst
+		starlog.NewColor(starlog.FgHiGreen),               //keepalive
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+		starlog.NewColor(starlog.FgWhite),                 //20=udp
+		starlog.NewColor(starlog.FgWhite),                 //0=unknown
+	}
+	nf.cap = bcap.NewPackets()
+	nf.ctx, nf.fn = context.WithCancel(context.Background())
+	return nf
+}
+
+func (n *Libpcap) logPrint(ctx context.Context) {
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case l := <-n.logCache:
+			if n.noShowMode {
+				fmt.Printf("已捕获报文数量:%v个\r", n.count)
+				continue
+			}
+			switch l.logLevel {
+			case "info":
+				starlog.Info(l.str)
+			case "notice":
+				starlog.Notice(l.str)
+			case "warning":
+				starlog.Warning(l.str)
+			case "error":
+				starlog.Error(l.str)
+			case "critical":
+				starlog.Critical(l.str)
+			case "debug":
+				starlog.Debug(l.str)
+			case "payload":
+				fmt.Println(l.str)
+			default:
+				n.printColor[l.stateLevel].Print(l.str)
+			}
+		}
+	}
+}
+
+func (n *Libpcap) ipInRange(ip string) bool {
+	if len(n.target) == 0 {
+		return false
+	}
+	for _, v := range n.target {
+		if v == ip {
+			return true
+		}
+	}
+	return false
+}
+
+func (n *Libpcap) strInRange(str string) bool {
+	if len(n.targetCmd) == 0 {
+		return false
+	}
+	for _, v := range n.targetCmd {
+		if v == "" {
+			continue
+		}
+		if strings.Contains(str, v) {
+			return true
+		}
+	}
+	return false
+}
+
+func (n *Libpcap) handlePacket(p gopacket.Packet) {
+	n.count++
+	if n.saveFile != "" {
+		n.packetCache <- p
+	}
+	var layer gopacket.Layer
+	for _, layerType := range []gopacket.LayerType{
+		layers.LayerTypeTCP, layers.LayerTypeUDP, layers.LayerTypeICMPv4, layers.LayerTypeICMPv6,
+		layers.LayerTypeIPv4, layers.LayerTypeIPv6, layers.LayerTypeARP,
+	} {
+		layer = p.Layer(layerType)
+		if layer == nil {
+			continue
+		}
+		break
+	}
+	if layer == nil {
+		n.logCache <- loged{
+			str:        "无法定义layer类型\n",
+			stateLevel: 0,
+			logLevel:   "error",
+		}
+		return
+	}
+	info, err := n.cap.ParsePacket(p)
+	if err != nil {
+		starlog.Errorln(err)
+		return
+	}
+	var dec string
+	switch info.StateDescript() {
+	case 0:
+		dec = "未知状态"
+	case 1:
+		dec = "SYN tcp建立一次握手"
+	case 2:
+		dec = "SYN,ACK tcp建立二次握手"
+	case 3:
+		dec = "ACK tcp建立三次握手"
+	case 4:
+		dec = "FIN tcp断开一次挥手"
+	case 5:
+		dec = "ACK tcp断开二次挥手"
+	case 6:
+		dec = "FIN,ACK tcp断开二次三次挥手"
+	case 7:
+		dec = "FIN tcp断开三次挥手"
+	case 8:
+		dec = "ACK tcp断开四次挥手"
+	case 9:
+		dec = "tcp报文"
+	case 10:
+		dec = "TCP重传"
+	case 11:
+		dec = "TCP ece"
+	case 12:
+		dec = "TCP cwr"
+	case 13:
+		dec = "TCP RST重置"
+	case 14:
+		dec = "TCP Keepalive"
+	}
+	if !n.showAll && !n.ipInRange(info.SrcIP) && !n.ipInRange(info.DstIP) {
+		return
+	}
+	n.logCache <- loged{
+		str: fmt.Sprintf("%s %v:%v -> %v:%v %s seq=%v ack=%v win=%v len=%v\n", time.Now().Format("2006-01-02 15:04:05.000000"), info.SrcIP, info.SrcPort,
+			info.DstIP, info.DstPort, dec, info.TcpSeq(), info.TcpAck(), info.TcpWindow(), info.TcpPayloads()),
+		stateLevel: int(info.StateDescript()),
+		logLevel:   "",
+	}
+
+	if n.showPayload {
+		str := string(layer.LayerPayload())
+		if n.maxShowPayloadSize > 0 {
+			if len(str) > n.maxShowPayloadSize {
+				str = str[:n.maxShowPayloadSize]
+			}
+		}
+		if n.showAsHex {
+			str = hex.EncodeToString([]byte(str))
+		}
+		n.logCache <- loged{
+			str:        str,
+			stateLevel: int(info.StateDescript()),
+			logLevel:   "payload",
+		}
+	}
+	if n.ipInRange(info.SrcIP) || n.ipInRange(info.DstIP) {
+		_, ok := n.blockMap.Load(info.Key)
+		if n.useRST && (ok || n.strInRange(string(layer.LayerPayload()))) {
+			n.blockMap.Store(info.Key, true)
+			starlog.Warningf("触发封禁关键词 RST重置\n")
+			RealSendRST(n.handle.Handle, info, n.rstMode, 3)
+		}
+	}
+}
+
+func (n *Libpcap) pcapWriter(stopCtx context.Context, fp *os.File) error {
+	w := pcapgo.NewWriter(fp)
+	err := w.WriteFileHeader(65535, layers.LinkTypeEthernet)
+	if err != nil {
+		return err
+	}
+	for {
+		select {
+		case <-stopCtx.Done():
+			return nil
+		case p := <-n.packetCache:
+			w.WritePacket(p.Metadata().CaptureInfo, p.Data())
+		}
+	}
+}
+
+func RealSendRST(p *pcap.Handle, info bcap.PacketInfo, target string, number int) {
+	for i := 0; i < number; i++ {
+		if target == "both" || target == "target" {
+			SendRST(p, info.SrcMac, info.DstMac, info.SrcIP, info.SrcPort, info.DstIP, info.DstPort, info.TcpSeq()+(uint32(i)*uint32(info.TcpWindow())))
+			//SendRST(p, info.DstMac, info.SrcMac, info.SrcIP, info.SrcPort, info.DstIP, info.DstPort, info.TcpSeq()+(uint32(i)*uint32(info.TcpWindow())))
+		}
+		if target == "both" || target == "reverse" {
+			SendRST(p, info.DstMac, info.SrcMac, info.DstIP, info.DstPort, info.SrcIP, info.SrcPort, info.TcpAck()+(uint32(i)*uint32(info.TcpWindow())))
+			//SendRST(p, info.SrcMac, info.DstMac, info.DstIP, info.DstPort, info.SrcIP, info.SrcPort, info.TcpAck()+(uint32(i)*uint32(info.TcpWindow())))
+		}
+	}
+}
+
+func SendRST(p *pcap.Handle, srcMac, dstMac []byte, srcIP, srcPort, dstIP, dstPort string, seq uint32) error {
+	if net.ParseIP(dstIP).To4() != nil {
+		return sendIPv4(p, srcMac, dstMac, srcIP, srcPort, dstIP, dstPort, seq, false)
+	}
+	return sendIPv6(p, srcMac, dstMac, srcIP, srcPort, dstIP, dstPort, seq, false)
+}
+
+func SendSYN(p *pcap.Handle, srcMac, dstMac []byte, srcIP, srcPort, dstIP, dstPort string, seq uint32) error {
+	if net.ParseIP(dstIP).To4() != nil {
+		return sendIPv4(p, srcMac, dstMac, srcIP, srcPort, dstIP, dstPort, seq, true)
+	}
+	return sendIPv6(p, srcMac, dstMac, srcIP, srcPort, dstIP, dstPort, seq, true)
+}
+
+func sendIPv4(p *pcap.Handle, srcMac, dstMac []byte, srcIP, srcPort, dstIP, dstPort string, seq uint32, isSyn bool) error {
+
+	dstNetIP := net.ParseIP(dstIP)
+	eth := layers.Ethernet{
+		SrcMAC:       srcMac,
+		DstMAC:       dstMac,
+		EthernetType: layers.EthernetTypeIPv4,
+	}
+	iPv4 := layers.IPv4{
+		SrcIP:    net.ParseIP(srcIP),
+		DstIP:    dstNetIP,
+		Version:  4,
+		TTL:      64,
+		Protocol: layers.IPProtocolTCP,
+	}
+	sPort, err := strconv.Atoi(srcPort)
+	if err != nil {
+		return err
+	}
+	dPort, err := strconv.Atoi(dstPort)
+	if err != nil {
+		return err
+	}
+	tcp := layers.TCP{
+		SrcPort: layers.TCPPort(sPort),
+		DstPort: layers.TCPPort(dPort),
+		Seq:     seq,
+		RST:     !isSyn,
+		SYN:     isSyn,
+	}
+
+	if err = tcp.SetNetworkLayerForChecksum(&iPv4); err != nil {
+		return err
+	}
+	buffer := gopacket.NewSerializeBuffer()
+	options := gopacket.SerializeOptions{
+		FixLengths:       true,
+		ComputeChecksums: true,
+	}
+	if srcMac == nil && dstMac == nil {
+		if err = gopacket.SerializeLayers(buffer, options, &iPv4, &tcp); err != nil {
+			return err
+		}
+	} else {
+		if err = gopacket.SerializeLayers(buffer, options, &eth, &iPv4, &tcp); err != nil {
+			return err
+		}
+	}
+	return p.WritePacketData(buffer.Bytes())
+}
+
+func sendIPv6(p *pcap.Handle, srcMac, dstMac []byte, srcIP, srcPort, dstIP, dstPort string, seq uint32, isSyn bool) error {
+	dstNetIP := net.ParseIP(dstIP)
+	eth := layers.Ethernet{
+		SrcMAC:       srcMac,
+		DstMAC:       dstMac,
+		EthernetType: layers.EthernetTypeIPv6,
+	}
+	iPv6 := layers.IPv6{
+		SrcIP:      net.ParseIP(srcIP),
+		DstIP:      dstNetIP,
+		Version:    6,
+		NextHeader: layers.IPProtocolTCP,
+		HopLimit:   64,
+	}
+	sPort, err := strconv.Atoi(srcPort)
+	if err != nil {
+		return err
+	}
+	dPort, err := strconv.Atoi(dstPort)
+	if err != nil {
+		return err
+	}
+	tcp := layers.TCP{
+		SrcPort: layers.TCPPort(sPort),
+		DstPort: layers.TCPPort(dPort),
+		Seq:     seq,
+		RST:     !isSyn,
+		SYN:     isSyn,
+	}
+	if err := tcp.SetNetworkLayerForChecksum(&iPv6); err != nil {
+		return err
+	}
+	buffer := gopacket.NewSerializeBuffer()
+	options := gopacket.SerializeOptions{
+		FixLengths:       true,
+		ComputeChecksums: true,
+	}
+	if srcMac == nil && dstMac == nil {
+		if err = gopacket.SerializeLayers(buffer, options, &iPv6, &tcp); err != nil {
+			return err
+		}
+	} else {
+		if err = gopacket.SerializeLayers(buffer, options, &eth, &iPv6, &tcp); err != nil {
+			return err
+		}
+	}
+	return p.WritePacketData(buffer.Bytes())
+}

tcpkill/cmd.go

@@ -0,0 +1,41 @@
+//go:build !(windows && arm64)
+
+package tcpkill
+
+import (
+	"github.com/spf13/cobra"
+	"os"
+	"runtime"
+)
+
+var tck = &TCPKill{}
+
+func init() {
+	Cmd.Flags().StringVarP(&tck.SrcIP, "src-ip", "s", "", "本地源IP")
+	Cmd.Flags().IntVarP(&tck.SrcPort, "src-port", "p", 0, "本地源端口")
+	Cmd.Flags().StringVarP(&tck.DstIP, "dst-ip", "d", "", "目标IP")
+	Cmd.Flags().IntVarP(&tck.DstPort, "dst-port", "P", 0, "目标端口")
+	Cmd.Flags().StringVarP(&tck.Status, "status", "S", "", "匹配的连接状态，如ESTABLISHED，CLOSE_WAIT等，为空则匹配所有")
+	Cmd.Flags().IntVarP(&tck.RstNumbers, "rst-numbers", "n", 3, "RST包数量")
+	Cmd.Flags().BoolVarP(&tck.WaitMode, "wait", "w", false, "等待模式")
+	Cmd.Flags().StringVarP(&tck.KillType, "kill-type", "t", "both", "RST通知类型,both=都通知 target=目标地址通知 reverse=来源地址通知")
+	if runtime.GOOS != "windows" {
+		Cmd.Flags().BoolVarP(&tck.AutoIptables, "auto-iptables", "a", true, "自动设置iptables")
+		Cmd.Flags().IntVarP(&tck.NFQNums, "nfq-nums", "q", 0, "NFQ队列号")
+	} else {
+		Cmd.Flags().StringVarP(&tck.Eth, "eth", "e", "", "网卡")
+		Cmd.Flags().StringVarP(&tck.BPF, "bpf", "b", "", "BPF过滤")
+		Cmd.Flags().StringVarP(&tck.Host, "host", "i", "", "主机")
+	}
+}
+
+var Cmd = &cobra.Command{
+	Use:   "tcpkill",
+	Short: "杀掉那个TCP连接",
+	Run: func(cmd *cobra.Command, args []string) {
+		err := tck.Run()
+		if err != nil {
+			os.Exit(1)
+		}
+	},
+}

tcpkill/cmd_winarm64.go

@@ -0,0 +1,16 @@
+//go:build windows && arm64
+
+package tcpkill
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+)
+
+var Cmd = &cobra.Command{
+	Use:   "tcpkill",
+	Short: "杀掉那个TCP连接",
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Println("windows on arm is not supported yet")
+	},
+}

tcpkill/tcpkill.go

@@ -0,0 +1,108 @@
+//go:build !(windows && arm64)
+
+package tcpkill
+
+import (
+	"b612.me/bcap"
+	"b612.me/starlog"
+	"context"
+	"fmt"
+	netm "github.com/shirou/gopsutil/v4/net"
+	"net"
+	"runtime"
+)
+
+func (t *TCPKill) PreRun() error {
+	if t.cap == nil {
+		t.cap = bcap.NewPackets()
+		t.ctx, t.stopFn = context.WithCancel(context.Background())
+	}
+	t.requests = make(chan *handler, 1024)
+	if t.KillType == "" {
+		t.KillType = "both"
+	}
+	conns, err := netm.Connections("tcp")
+	if err != nil {
+		starlog.Errorf("Failed to get system connections:%v\n", err)
+		return err
+	}
+	starlog.Infof("Got %d connections\n", len(conns))
+	for _, conn := range conns {
+		//fmt.Printf("Connection: %v => %v PID=%v Status=%v\n", conn.Laddr, conn.Raddr, conn.Pid, conn.Status)
+		if t.Match(conn) {
+			fmt.Printf("Matched connection: %v:%v => %v:%v PID=%v Status=%v\n", conn.Laddr.IP, conn.Laddr.Port, conn.Raddr.IP, conn.Raddr.Port, conn.Pid, conn.Status)
+			t.matchConns.Store(key(conn), conn)
+			t.matchCount++
+		}
+	}
+	if t.matchCount == 0 && !t.WaitMode {
+		starlog.Warningln("No matched connection")
+		return fmt.Errorf("No matched connection")
+	}
+	starlog.Infof("Matched %d connections\n", t.matchCount)
+	return nil
+}
+
+func (t *TCPKill) Match(info netm.ConnectionStat) bool {
+	if info.Status != "PCAP" {
+		if t.Status != "" && t.Status != info.Status {
+			return false
+		}
+		if info.Status == "DELETE" || info.Status == "CLOSED" || info.Status == "LISTEN" {
+			return false
+		}
+		if runtime.GOOS == "windows" && info.Status == "TIME_WAIT" {
+			return false
+		}
+	}
+	if _, ok := t.matchConns.Load(key(info)); ok {
+		return true
+	}
+	if t.SrcIP == "" && t.SrcPort == 0 && t.DstIP == "" && t.DstPort == 0 {
+		if t.Status != "" && info.Status != "PCAP" {
+			return true
+		}
+		return false
+	}
+	innerCheck := func(srcIP string, srcPort int, conns netm.Addr) bool {
+		sIp := net.ParseIP(srcIP)
+		if sIp == nil {
+			return false
+		}
+		lAddr := net.ParseIP(conns.IP)
+		if lAddr != nil {
+			if sIp.To16() != nil && lAddr.To16() != nil && !lAddr.To16().Equal(sIp.To16()) {
+				return false
+			}
+			if sIp.To4() != nil && lAddr.To4() != nil && !lAddr.To4().Equal(sIp.To4()) {
+				return false
+			}
+			if (sIp.To4() != nil && lAddr.To4() == nil) || (sIp.To4() == nil && lAddr.To4() != nil) {
+				return false
+			}
+			if srcPort != 0 && uint32(srcPort) != conns.Port {
+				return false
+			}
+		}
+		return true
+	}
+	if t.SrcIP != "" {
+		if !innerCheck(t.SrcIP, t.SrcPort, info.Laddr) {
+			return false
+		}
+	} else if t.SrcPort != 0 && t.SrcPort != int(info.Laddr.Port) {
+		return false
+	}
+	if t.DstIP != "" {
+		if !innerCheck(t.DstIP, t.DstPort, info.Raddr) {
+			return false
+		}
+	} else if t.DstPort != 0 && t.DstPort != int(info.Raddr.Port) {
+		return false
+	}
+	return true
+}
+
+func key(i netm.ConnectionStat) string {
+	return fmt.Sprintf("tcp://%v:%v-%v:%v", i.Laddr.IP, i.Laddr.Port, i.Raddr.IP, i.Raddr.Port)
+}

tcpkill/tcpkill_unix.go

@@ -0,0 +1,372 @@
+//go:build !windows
+
+package tcpkill
+
+import (
+	"b612.me/bcap"
+	"b612.me/bcap/nfq"
+	"b612.me/starlog"
+	"context"
+	"fmt"
+	"github.com/florianl/go-nfqueue/v2"
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	netm "github.com/shirou/gopsutil/v4/net"
+	"net"
+	"os"
+	"os/exec"
+	"os/signal"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+)
+
+type TCPKill struct {
+	NFQNums      int
+	AutoIptables bool
+	SrcIP        string
+	SrcPort      int
+	DstIP        string
+	DstPort      int
+	Status       string
+	KillType     string
+	RstNumbers   int
+	WaitMode     bool
+	matchConns   sync.Map
+	matchCount   uint
+	sync.Mutex
+	cache    []string
+	cap      *bcap.Packets
+	ctx      context.Context
+	stopFn   context.CancelFunc
+	requests chan *handler
+	BPF      string
+	Eth      string
+	Host     string
+}
+
+func (t *TCPKill) doIptables() error {
+	if t.SrcPort != 0 {
+		if _, err := exec.Command("iptables", "-t", "raw", "-A", "PREROUTING", "-p", "tcp", "--dport", strconv.Itoa(t.SrcPort), "-j", "NFQUEUE", "--queue-num", strconv.Itoa(t.NFQNums)).CombinedOutput(); err != nil {
+			return err
+		}
+		t.cache = append(t.cache, "-t raw -D PREROUTING -p tcp --dport "+strconv.Itoa(t.SrcPort)+" -j NFQUEUE --queue-num "+strconv.Itoa(t.NFQNums))
+		if _, err := exec.Command("iptables", "-t", "raw", "-A", "OUTPUT", "-p", "tcp", "--sport", strconv.Itoa(t.SrcPort), "-j", "NFQUEUE", "--queue-num", strconv.Itoa(t.NFQNums)).CombinedOutput(); err != nil {
+			return err
+		}
+		t.cache = append(t.cache, "-t raw -D OUTPUT -p tcp --sport "+strconv.Itoa(t.SrcPort)+" -j NFQUEUE --queue-num "+strconv.Itoa(t.NFQNums))
+		return nil
+	}
+	if t.DstPort != 0 {
+		if _, err := exec.Command("iptables", "-t", "raw", "-A", "PREROUTING", "-p", "tcp", "--sport", strconv.Itoa(t.DstPort), "-j", "NFQUEUE", "--queue-num", strconv.Itoa(t.NFQNums)).CombinedOutput(); err != nil {
+			return err
+		}
+		t.cache = append(t.cache, "-t raw -D PREROUTING -p tcp --sport "+strconv.Itoa(t.DstPort)+" -j NFQUEUE --queue-num "+strconv.Itoa(t.NFQNums))
+		if _, err := exec.Command("iptables", "-t", "raw", "-A", "OUTPUT", "-p", "tcp", "--dport", strconv.Itoa(t.DstPort), "-j", "NFQUEUE", "--queue-num", strconv.Itoa(t.NFQNums)).CombinedOutput(); err != nil {
+			return err
+		}
+		t.cache = append(t.cache, "-t raw -D OUTPUT -p tcp --dport "+strconv.Itoa(t.DstPort)+" -j NFQUEUE --queue-num "+strconv.Itoa(t.NFQNums))
+		return nil
+	}
+	return fmt.Errorf("No src or dst port detect,it is too dangerous to set iptables automatically without port,please operate manually")
+}
+
+func (t *TCPKill) undoIptables() {
+	for _, cmd := range t.cache {
+		exec.Command("iptables", strings.Fields(cmd)...).CombinedOutput()
+	}
+}
+
+func (t *TCPKill) Run() error {
+	if err := t.PreRun(); err != nil {
+		return err
+	}
+	stopSignal := make(chan os.Signal)
+	starlog.Noticef("Starting nfqueue capture\n")
+	nf := nfq.NewNfQueue(t.ctx, uint16(t.NFQNums), 65535)
+	nf.SetRecall(t.handleRoute)
+	go func() {
+		if err := nf.Run(); err != nil {
+			starlog.Errorln(err)
+			stopSignal <- syscall.SIGKILL
+		}
+	}()
+	if t.AutoIptables {
+		if _, err := exec.Command("iptables", "-V").CombinedOutput(); err != nil {
+			starlog.Warningln("iptables not found, cannot auto set iptables")
+			return fmt.Errorf("iptables not found")
+		}
+		defer t.undoIptables()
+		if err := t.doIptables(); err != nil {
+			starlog.Errorf("Failed to set iptables:%v\n", err)
+			return err
+		}
+		starlog.Infof("Set iptables success\n")
+	}
+	signal.Notify(stopSignal, syscall.SIGINT, syscall.SIGTERM, syscall.SIGKILL)
+	go t.SynSent()
+	go t.handleNfResult()
+	select {
+	//todo need nf.Stop()
+	case <-stopSignal:
+		starlog.Warningf("Received stop signal\n")
+
+	case <-t.ctx.Done():
+		starlog.Infoln("TCPKILL Task Finished")
+
+	}
+	return nil
+
+}
+
+func (t *TCPKill) handleNfResult() {
+	for {
+		select {
+		case <-t.ctx.Done():
+			return
+		case info := <-t.requests:
+			if info == nil {
+				continue
+			}
+			info.p.SetVerdict(info.id, <-info.fin)
+		}
+	}
+}
+
+func (t *TCPKill) handleRoute(id uint32, q *nfqueue.Nfqueue, p nfq.Packet) {
+	if t.requests == nil {
+		q.SetVerdict(id, nfqueue.NfAccept)
+		return
+	}
+	info, err := t.cap.ParsePacket(p.Packet)
+	if err != nil {
+		q.SetVerdict(id, nfqueue.NfAccept)
+		return
+	}
+	fin := make(chan int)
+	t.requests <- &handler{
+		id:     id,
+		p:      q,
+		packet: p.Packet,
+		attr:   p.Attr,
+		fin:    fin,
+	}
+	go func() {
+		fin <- t.handlePacket(info, p)
+	}()
+}
+
+type handler struct {
+	id     uint32
+	p      *nfqueue.Nfqueue
+	packet gopacket.Packet
+	attr   nfqueue.Attribute
+	fin    chan int
+}
+
+func (t *TCPKill) handlePacket(info bcap.PacketInfo, p nfq.Packet) int {
+	if p.Packet == nil {
+		return nfqueue.NfAccept
+	}
+	tcpLayer := p.Packet.Layer(layers.LayerTypeTCP)
+	if tcpLayer == nil {
+		return nfqueue.NfAccept
+	}
+	tcp := tcpLayer.(*layers.TCP)
+	if tcp.SYN && !tcp.ACK {
+		//starlog.Debugf("SYN packet:%v\n", p.Packet)
+		return nfqueue.NfAccept
+	}
+	if tcp.RST {
+		starlog.Warningf("RST packet:%v <==> %v\n", info.SrcIP+":"+info.SrcPort, info.DstIP+":"+info.DstPort)
+		return nfqueue.NfAccept
+	}
+	if !t.Match(netm.ConnectionStat{
+		Status: "PCAP",
+		Laddr: netm.Addr{
+			IP:   info.SrcIP,
+			Port: uint32(tcp.SrcPort),
+		},
+		Raddr: netm.Addr{
+			IP:   info.DstIP,
+			Port: uint32(tcp.DstPort),
+		},
+	}) && !t.Match(netm.ConnectionStat{
+		Status: "PCAP",
+		Raddr: netm.Addr{
+			IP:   info.SrcIP,
+			Port: uint32(tcp.SrcPort),
+		},
+		Laddr: netm.Addr{
+			IP:   info.DstIP,
+			Port: uint32(tcp.DstPort),
+		},
+	}) {
+		return nfqueue.NfAccept
+	}
+	RealSendRST(info, t.KillType, t.RstNumbers)
+	return nfqueue.NfAccept
+}
+
+func (t *TCPKill) SynSent() {
+	for {
+		time.Sleep(time.Millisecond * 2500)
+		realConns, err := netm.Connections("tcp")
+		if err != nil {
+			continue
+		}
+		t.matchConns.Range(func(key, value any) bool {
+			t.matchConns.Delete(key)
+			t.matchCount--
+			return true
+		})
+		for _, conn := range realConns {
+			if t.Match(conn) {
+				t.matchConns.Store(key(conn), conn)
+				t.matchCount++
+			}
+		}
+		if t.matchCount == 0 && !t.WaitMode {
+			starlog.Warningln("No matched connection anymore")
+			t.stopFn()
+			return
+		}
+		t.matchConns.Range(func(k, v any) bool {
+			conn := v.(netm.ConnectionStat)
+			if err := SendSYN(conn.Laddr.IP, strconv.Itoa(int(conn.Laddr.Port)), conn.Raddr.IP, strconv.Itoa(int(conn.Raddr.Port)), 1127); err != nil {
+				starlog.Errorf("Failed to send SYN:%v\n", err)
+			}
+			if err := SendSYN(conn.Raddr.IP, strconv.Itoa(int(conn.Raddr.Port)), conn.Laddr.IP, strconv.Itoa(int(conn.Laddr.Port)), 1127); err != nil {
+				starlog.Errorf("Failed to send SYN:%v\n", err)
+			}
+			starlog.Infof("Send SYN to %v <==> %v\n", conn.Laddr.String(), conn.Raddr.String())
+			return true
+		})
+	}
+}
+
+func RealSendRST(info bcap.PacketInfo, target string, number int) {
+	for i := 0; i < number; i++ {
+		if target == "both" || target == "target" {
+			seq := uint32(info.TcpPayloads()) + info.TcpSeq() + (uint32(i) * uint32(info.TcpWindow()))
+			SendRST(info.SrcIP, info.SrcPort, info.DstIP, info.DstPort, seq)
+		}
+		if target == "both" || target == "reverse" {
+			SendRST(info.DstIP, info.DstPort, info.SrcIP, info.SrcPort, info.TcpAck()+(uint32(i)*uint32(info.TcpWindow())))
+		}
+	}
+}
+
+func SendRST(srcIP, srcPort, dstIP, dstPort string, seq uint32) error {
+	if net.ParseIP(dstIP).To4() != nil {
+		return sendIPv4(srcIP, srcPort, dstIP, dstPort, seq, false)
+	}
+	return sendIPv6(srcIP, srcPort, dstIP, dstPort, seq, false)
+}
+
+func SendSYN(srcIP, srcPort, dstIP, dstPort string, seq uint32) error {
+	if net.ParseIP(dstIP).To4() != nil {
+		return sendIPv4(srcIP, srcPort, dstIP, dstPort, seq, true)
+	}
+	return sendIPv6(srcIP, srcPort, dstIP, dstPort, seq, true)
+}
+
+func sendIPv4(srcIP, srcPort, dstIP, dstPort string, seq uint32, isSyn bool) error {
+	fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_RAW, syscall.IPPROTO_RAW)
+	if err != nil {
+		return err
+	}
+	defer syscall.Close(fd)
+
+	dstNetIP := net.ParseIP(dstIP)
+	iPv4 := layers.IPv4{
+		SrcIP:    net.ParseIP(srcIP),
+		DstIP:    dstNetIP,
+		Version:  4,
+		TTL:      64,
+		Protocol: layers.IPProtocolTCP,
+	}
+	sPort, err := strconv.Atoi(srcPort)
+	if err != nil {
+		return err
+	}
+	dPort, err := strconv.Atoi(dstPort)
+	if err != nil {
+		return err
+	}
+	tcp := layers.TCP{
+		SrcPort: layers.TCPPort(sPort),
+		DstPort: layers.TCPPort(dPort),
+		Seq:     seq,
+		RST:     !isSyn,
+		SYN:     isSyn,
+	}
+
+	if err = tcp.SetNetworkLayerForChecksum(&iPv4); err != nil {
+		return err
+	}
+	buffer := gopacket.NewSerializeBuffer()
+	options := gopacket.SerializeOptions{
+		FixLengths:       true,
+		ComputeChecksums: true,
+	}
+	if err = gopacket.SerializeLayers(buffer, options, &iPv4, &tcp); err != nil {
+		return err
+	}
+	addr := syscall.SockaddrInet4{
+		Port: dPort,
+		Addr: [4]byte{dstNetIP.To4()[0], dstNetIP.To4()[1], dstNetIP.To4()[2], dstNetIP.To4()[3]},
+	}
+	return syscall.Sendto(fd, buffer.Bytes(), 0, &addr)
+}
+
+func sendIPv6(srcIP, srcPort, dstIP, dstPort string, seq uint32, isSyn bool) error {
+	fd, err := syscall.Socket(syscall.AF_INET6, syscall.SOCK_RAW, syscall.IPPROTO_RAW)
+	if err != nil {
+		return err
+	}
+	defer syscall.Close(fd)
+
+	dstNetIP := net.ParseIP(dstIP)
+	iPv6 := layers.IPv6{
+		SrcIP:      net.ParseIP(srcIP),
+		DstIP:      dstNetIP,
+		Version:    6,
+		NextHeader: layers.IPProtocolTCP,
+		HopLimit:   64,
+	}
+	sPort, err := strconv.Atoi(srcPort)
+	if err != nil {
+		return err
+	}
+	dPort, err := strconv.Atoi(dstPort)
+	if err != nil {
+		return err
+	}
+	tcp := layers.TCP{
+		SrcPort: layers.TCPPort(sPort),
+		DstPort: layers.TCPPort(dPort),
+		Seq:     seq,
+		RST:     !isSyn,
+		SYN:     isSyn,
+	}
+
+	if err := tcp.SetNetworkLayerForChecksum(&iPv6); err != nil {
+		return err
+	}
+	buffer := gopacket.NewSerializeBuffer()
+	options := gopacket.SerializeOptions{
+		FixLengths:       true,
+		ComputeChecksums: true,
+	}
+	if err = gopacket.SerializeLayers(buffer, options, &iPv6, &tcp); err != nil {
+		return err
+	}
+	addr := syscall.SockaddrInet6{
+		Port: dPort,
+		Addr: [16]byte(dstNetIP.To16()),
+	}
+	return syscall.Sendto(fd, buffer.Bytes(), 0, &addr)
+}

tcpkill/tcpkill_windows.go

@@ -0,0 +1,390 @@
+//go:build windows && (amd64 || 386)
+
+package tcpkill
+
+import (
+	"b612.me/bcap"
+	"b612.me/bcap/libpcap"
+	"b612.me/starlog"
+	"context"
+	"fmt"
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/google/gopacket/pcap"
+	netm "github.com/shirou/gopsutil/v4/net"
+	"net"
+	"os"
+	"os/signal"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+)
+
+type TCPKill struct {
+	NFQNums      int
+	AutoIptables bool
+	BPF          string
+	Eth          string
+	Host         string
+	SrcIP        string
+	SrcPort      int
+	DstIP        string
+	DstPort      int
+	KillType     string
+	RstNumbers   int
+	WaitMode     bool
+	Status       string
+	matchConns   sync.Map
+	matchCount   uint
+	sync.Mutex
+	cache    []string
+	cap      *bcap.Packets
+	ctx      context.Context
+	stopFn   context.CancelFunc
+	requests chan *handler
+	pc       *libpcap.NetCatch
+	macCache map[string]net.HardwareAddr
+}
+
+type handler struct {
+}
+
+func (t *TCPKill) presetWindows() {
+	t.macCache = make(map[string]net.HardwareAddr)
+	if t.BPF == "" {
+		if t.DstIP != "" {
+			t.BPF = fmt.Sprintf("tcp and host %s", t.DstIP)
+		} else if t.SrcIP != "" {
+			t.BPF = fmt.Sprintf("tcp and host %s", t.SrcIP)
+		} else if t.SrcPort != 0 {
+			t.BPF = fmt.Sprintf("tcp and port %d", t.SrcPort)
+		} else if t.DstPort != 0 {
+			t.BPF = fmt.Sprintf("tcp and port %d", t.DstPort)
+		} else {
+			t.BPF = "tcp"
+		}
+	}
+	if t.Eth == "" && t.Host == "" {
+		allDevice, err := pcap.FindAllDevs()
+		if err != nil {
+			starlog.Errorf("get pcap devices failed:%v\n", err)
+			return
+		}
+		if t.SrcIP == "" {
+			defer func() {
+				t.SrcIP = ""
+			}()
+			ip := t.DstIP
+			if ip == "" {
+				ip = "223.6.6.6"
+			}
+			if strings.Contains(ip, ":") {
+				ip = "[" + ip + "]"
+			}
+			l, err := net.Dial("udp", ip+":53")
+			if err == nil {
+				t.SrcIP = l.LocalAddr().(*net.UDPAddr).IP.String()
+				starlog.Infof("No eth or ip detected,use %s as source ip\n", t.SrcIP)
+				l.Close()
+			} else {
+				starlog.Errorf("Failed to get source ip:%v\n", err)
+			}
+		}
+		for _, v := range allDevice {
+			if t.SrcIP == "127.0.0.1" && v.Name == "\\Device\\NPF_Loopback" {
+				t.Eth = v.Name
+				return
+			}
+			for _, addr := range v.Addresses {
+				if addr.IP.String() == t.SrcIP {
+					t.Eth = v.Name
+					return
+				}
+			}
+		}
+
+	}
+}
+
+func (t *TCPKill) Run() error {
+	var err error
+	if err = t.PreRun(); err != nil {
+		return err
+	}
+	t.presetWindows()
+	stopSignal := make(chan os.Signal)
+	starlog.Noticef("Starting capture\n")
+	signal.Notify(stopSignal, syscall.SIGINT, syscall.SIGTERM, syscall.SIGKILL)
+	if t.Eth != "" {
+		t.pc, err = libpcap.NewCatchEth(t.Eth, t.BPF)
+		if err != nil {
+			starlog.Errorf("Failed to create pcap handle:%v\n", err)
+			return err
+		}
+	}
+	if t.Host != "" {
+		t.pc, err = libpcap.NewCatch(t.Host, t.BPF)
+		if err != nil {
+			starlog.Errorf("Failed to create pcap handle:%v\n", err)
+			return err
+		}
+	}
+	if t.pc == nil {
+		starlog.Errorf("No pcap handle\n")
+		return fmt.Errorf("No pcap handle")
+	}
+	t.pc.SetRecall(t.handlePacket)
+	go func() {
+		if err := t.pc.Run(); err != nil {
+			starlog.Errorln(err)
+			stopSignal <- syscall.SIGKILL
+		}
+	}()
+	go t.SynSent()
+	select {
+	//todo need nf.Stop()
+	case <-stopSignal:
+		starlog.Warningf("Received stop signal\n")
+
+	case <-t.ctx.Done():
+		starlog.Infoln("TCPKILL Task Finished")
+
+	}
+	return nil
+
+}
+
+func (t *TCPKill) SynSent() {
+	for {
+		time.Sleep(time.Millisecond * 2500)
+		realConns, err := netm.Connections("tcp")
+		if err != nil {
+			continue
+		}
+		t.matchConns.Range(func(key, value any) bool {
+			t.matchConns.Delete(key)
+			t.matchCount--
+			return true
+		})
+		for _, conn := range realConns {
+			if t.Match(conn) {
+				t.matchConns.Store(key(conn), conn)
+				t.matchCount++
+			}
+		}
+		if t.matchCount == 0 && !t.WaitMode {
+			starlog.Warningln("No matched connection anymore")
+			t.stopFn()
+			return
+		}
+		t.matchConns.Range(func(k, v any) bool {
+			conn := v.(netm.ConnectionStat)
+			if t.macCache[conn.Laddr.IP] == nil || t.macCache[conn.Raddr.IP] == nil {
+				target := conn.Raddr.IP + ":" + strconv.Itoa(int(conn.Raddr.Port))
+				if strings.Contains(conn.Raddr.IP, ":") {
+					target = "[" + conn.Raddr.IP + "]:" + strconv.Itoa(int(conn.Raddr.Port))
+				}
+				starlog.Warningf("No mac address for %v or %v,try send syn to %v\n", conn.Laddr.IP, conn.Raddr.IP, target)
+				tcpConn, err := net.DialTimeout("tcp", target, time.Millisecond*800)
+				if err == nil {
+					tcpConn.(*net.TCPConn).SetLinger(0)
+					tcpConn.Close()
+				}
+				time.Sleep(time.Millisecond * 600)
+			}
+			t.Lock()
+			if err := SendSYN(t.pc.Handle, t.macCache[conn.Laddr.IP], t.macCache[conn.Raddr.IP], conn.Laddr.IP, strconv.Itoa(int(conn.Laddr.Port)), conn.Raddr.IP, strconv.Itoa(int(conn.Raddr.Port)), 1127); err != nil {
+				starlog.Errorf("Failed to send SYN:%v\n", err)
+			}
+			if err := SendSYN(t.pc.Handle, t.macCache[conn.Raddr.IP], t.macCache[conn.Laddr.IP], conn.Raddr.IP, strconv.Itoa(int(conn.Raddr.Port)), conn.Laddr.IP, strconv.Itoa(int(conn.Laddr.Port)), 1127); err != nil {
+				starlog.Errorf("Failed to send SYN:%v\n", err)
+			}
+			t.Unlock()
+			starlog.Infof("Send SYN to %v <==> %v\n", conn.Laddr.String(), conn.Raddr.String())
+			return true
+		})
+	}
+}
+
+func (t *TCPKill) handlePacket(p gopacket.Packet) {
+	t.Lock()
+	info, err := t.cap.ParsePacket(p)
+	t.Unlock()
+	if err != nil {
+		return
+	}
+	tcpLayer := p.Layer(layers.LayerTypeTCP)
+	if tcpLayer == nil {
+		return
+	}
+	tcp := tcpLayer.(*layers.TCP)
+	if tcp.SYN && !tcp.ACK {
+		return
+	}
+	t.Lock()
+	//fmt.Println(info.SrcIP, hex.EncodeToString(info.SrcMac), info.DstIP, hex.EncodeToString(info.DstMac))
+	t.macCache[info.SrcIP] = info.SrcMac
+	t.macCache[info.DstIP] = info.DstMac
+	t.Unlock()
+	if tcp.RST {
+		starlog.Warningf("RST packet:%v <==> %v\n", info.SrcIP+":"+info.SrcPort, info.DstIP+":"+info.DstPort)
+		return
+	}
+	//starlog.Debugf("packet:%v <==> %v\n", info.SrcIP+":"+info.SrcPort, info.DstIP+":"+info.DstPort)
+	if !t.Match(netm.ConnectionStat{
+		Status: "PCAP",
+		Laddr: netm.Addr{
+			IP:   info.SrcIP,
+			Port: uint32(tcp.SrcPort),
+		},
+		Raddr: netm.Addr{
+			IP:   info.DstIP,
+			Port: uint32(tcp.DstPort),
+		},
+	}) && !t.Match(netm.ConnectionStat{
+		Status: "PCAP",
+		Raddr: netm.Addr{
+			IP:   info.SrcIP,
+			Port: uint32(tcp.SrcPort),
+		},
+		Laddr: netm.Addr{
+			IP:   info.DstIP,
+			Port: uint32(tcp.DstPort),
+		},
+	}) {
+		return
+	}
+	starlog.Noticef("Sending RST... %v:%v <==> %v:%v SEQ=%d ACK=%d\n", info.SrcIP, info.SrcPort, info.DstIP, info.DstPort, info.TcpSeq(), info.TcpAck())
+	RealSendRST(t.pc.Handle, info, t.KillType, t.RstNumbers)
+}
+
+func RealSendRST(p *pcap.Handle, info bcap.PacketInfo, target string, number int) {
+	for i := 0; i < number; i++ {
+		if target == "both" || target == "target" {
+			seq := uint32(info.TcpPayloads()) + info.TcpSeq() + (uint32(i) * uint32(info.TcpWindow()))
+			SendRST(p, info.SrcMac, info.DstMac, info.SrcIP, info.SrcPort, info.DstIP, info.DstPort, seq)
+			//SendRST(p, info.DstMac, info.SrcMac, info.SrcIP, info.SrcPort, info.DstIP, info.DstPort, info.TcpSeq()+(uint32(i)*uint32(info.TcpWindow())))
+
+		}
+		if target == "both" || target == "reverse" {
+			SendRST(p, info.DstMac, info.SrcMac, info.DstIP, info.DstPort, info.SrcIP, info.SrcPort, info.TcpAck()+(uint32(i)*uint32(info.TcpWindow())))
+			//SendRST(p, info.SrcMac, info.DstMac, info.DstIP, info.DstPort, info.SrcIP, info.SrcPort, info.TcpAck()+(uint32(i)*uint32(info.TcpWindow())))
+		}
+	}
+}
+
+func SendRST(p *pcap.Handle, srcMac, dstMac []byte, srcIP, srcPort, dstIP, dstPort string, seq uint32) error {
+	if net.ParseIP(dstIP).To4() != nil {
+		return sendIPv4(p, srcMac, dstMac, srcIP, srcPort, dstIP, dstPort, seq, false)
+	}
+	return sendIPv6(p, srcMac, dstMac, srcIP, srcPort, dstIP, dstPort, seq, false)
+}
+
+func SendSYN(p *pcap.Handle, srcMac, dstMac []byte, srcIP, srcPort, dstIP, dstPort string, seq uint32) error {
+	if net.ParseIP(dstIP).To4() != nil {
+		return sendIPv4(p, srcMac, dstMac, srcIP, srcPort, dstIP, dstPort, seq, true)
+	}
+	return sendIPv6(p, srcMac, dstMac, srcIP, srcPort, dstIP, dstPort, seq, true)
+}
+
+func sendIPv4(p *pcap.Handle, srcMac, dstMac []byte, srcIP, srcPort, dstIP, dstPort string, seq uint32, isSyn bool) error {
+
+	dstNetIP := net.ParseIP(dstIP)
+	eth := layers.Ethernet{
+		SrcMAC:       srcMac,
+		DstMAC:       dstMac,
+		EthernetType: layers.EthernetTypeIPv4,
+	}
+	iPv4 := layers.IPv4{
+		SrcIP:    net.ParseIP(srcIP),
+		DstIP:    dstNetIP,
+		Version:  4,
+		TTL:      64,
+		Protocol: layers.IPProtocolTCP,
+	}
+	sPort, err := strconv.Atoi(srcPort)
+	if err != nil {
+		return err
+	}
+	dPort, err := strconv.Atoi(dstPort)
+	if err != nil {
+		return err
+	}
+	tcp := layers.TCP{
+		SrcPort: layers.TCPPort(sPort),
+		DstPort: layers.TCPPort(dPort),
+		Seq:     seq,
+		RST:     !isSyn,
+		SYN:     isSyn,
+	}
+
+	if err = tcp.SetNetworkLayerForChecksum(&iPv4); err != nil {
+		return err
+	}
+	buffer := gopacket.NewSerializeBuffer()
+	options := gopacket.SerializeOptions{
+		FixLengths:       true,
+		ComputeChecksums: true,
+	}
+	if srcMac == nil && dstMac == nil {
+		if err = gopacket.SerializeLayers(buffer, options, &iPv4, &tcp); err != nil {
+			return err
+		}
+	} else {
+		if err = gopacket.SerializeLayers(buffer, options, &eth, &iPv4, &tcp); err != nil {
+			return err
+		}
+	}
+	return p.WritePacketData(buffer.Bytes())
+}
+
+func sendIPv6(p *pcap.Handle, srcMac, dstMac []byte, srcIP, srcPort, dstIP, dstPort string, seq uint32, isSyn bool) error {
+	dstNetIP := net.ParseIP(dstIP)
+	eth := layers.Ethernet{
+		SrcMAC:       srcMac,
+		DstMAC:       dstMac,
+		EthernetType: layers.EthernetTypeIPv6,
+	}
+	iPv6 := layers.IPv6{
+		SrcIP:      net.ParseIP(srcIP),
+		DstIP:      dstNetIP,
+		Version:    6,
+		NextHeader: layers.IPProtocolTCP,
+		HopLimit:   64,
+	}
+	sPort, err := strconv.Atoi(srcPort)
+	if err != nil {
+		return err
+	}
+	dPort, err := strconv.Atoi(dstPort)
+	if err != nil {
+		return err
+	}
+	tcp := layers.TCP{
+		SrcPort: layers.TCPPort(sPort),
+		DstPort: layers.TCPPort(dPort),
+		Seq:     seq,
+		RST:     !isSyn,
+		SYN:     isSyn,
+	}
+	if err := tcp.SetNetworkLayerForChecksum(&iPv6); err != nil {
+		return err
+	}
+	buffer := gopacket.NewSerializeBuffer()
+	options := gopacket.SerializeOptions{
+		FixLengths:       true,
+		ComputeChecksums: true,
+	}
+	if srcMac == nil && dstMac == nil {
+		if err = gopacket.SerializeLayers(buffer, options, &iPv6, &tcp); err != nil {
+			return err
+		}
+	} else {
+		if err = gopacket.SerializeLayers(buffer, options, &eth, &iPv6, &tcp); err != nil {
+			return err
+		}
+	}
+	return p.WritePacketData(buffer.Bytes())
+}

version/version.go

@@ -0,0 +1,3 @@
+package version
+
+var Version = "2.1.0.beta.15"