2025-06-23 09:30:39

Author: mohanson

cmd/daze/main.go

@@ -169,46 +169,46 @@ func main() {
 		switch *flProtoc {
 		case "ashe":
 			client := ashe.NewClient(*flServer, *flCipher)
-			if *flLimits != "" {
-				n := daze.SizeParser(*flLimits)
-				doa.Doa(n <= math.MaxInt)
-				client.Limits = rate.NewLimiter(rate.Limit(n), int(n))
-			}
 			locale := daze.NewLocale(*flListen, daze.NewAimbot(client, &daze.AimbotOption{
 				Type: *flFilter,
 				Rule: *flRulels,
 				Cidr: *flCIDRls,
 			}))
 			defer locale.Close()
-			doa.Nil(locale.Run())
-		case "baboon":
-			client := baboon.NewClient(*flServer, *flCipher)
 			if *flLimits != "" {
 				n := daze.SizeParser(*flLimits)
 				doa.Doa(n <= math.MaxInt)
-				client.Limits = rate.NewLimiter(rate.Limit(n), int(n))
+				locale.Limits = rate.NewLimiter(rate.Limit(n), int(n))
 			}
+			doa.Nil(locale.Run())
+		case "baboon":
+			client := baboon.NewClient(*flServer, *flCipher)
 			locale := daze.NewLocale(*flListen, daze.NewAimbot(client, &daze.AimbotOption{
 				Type: *flFilter,
 				Rule: *flRulels,
 				Cidr: *flCIDRls,
 			}))
 			defer locale.Close()
-			doa.Nil(locale.Run())
-		case "czar":
-			client := czar.NewClient(*flServer, *flCipher)
-			defer client.Close()
 			if *flLimits != "" {
 				n := daze.SizeParser(*flLimits)
 				doa.Doa(n <= math.MaxInt)
-				client.Limits = rate.NewLimiter(rate.Limit(n), int(n))
+				locale.Limits = rate.NewLimiter(rate.Limit(n), int(n))
 			}
+			doa.Nil(locale.Run())
+		case "czar":
+			client := czar.NewClient(*flServer, *flCipher)
+			defer client.Close()
 			locale := daze.NewLocale(*flListen, daze.NewAimbot(client, &daze.AimbotOption{
 				Type: *flFilter,
 				Rule: *flRulels,
 				Cidr: *flCIDRls,
 			}))
 			defer locale.Close()
+			if *flLimits != "" {
+				n := daze.SizeParser(*flLimits)
+				doa.Doa(n <= math.MaxInt)
+				locale.Limits = rate.NewLimiter(rate.Limit(n), int(n))
+			}
 			doa.Nil(locale.Run())
 		case "dahlia":
 			client := dahlia.NewClient(*flListen, *flServer, *flCipher)

daze.go

@@ -190,9 +190,10 @@ func (d *Direct) Dial(ctx *Context, network string, address string) (io.ReadWrit
 
 // Locale is the main process of daze. In most cases, it is usually deployed as a daemon on a local machine.
 type Locale struct {
-	Listen string
-	Dialer Dialer
 	Closer io.Closer
+	Dialer Dialer
+	Limits *rate.Limiter
+	Listen string
 }
 
 // ServeProxy serves traffic in HTTP Proxy/Tunnel format.
@@ -551,6 +552,10 @@ func (l *Locale) Serve(ctx *Context, cli io.ReadWriteCloser) error {
 		buf = make([]byte, 1)
 		err error
 	)
+	cli = &RateConn{
+		Conn: cli,
+		Rate: l.Limits,
+	}
 	_, err = io.ReadFull(cli, buf)
 	if err != nil {
 		// There are some clients that will establish a link in advance without sending any messages so that they can
@@ -621,8 +626,9 @@ func (l *Locale) Run() error {
 // NewLocale returns a Locale.
 func NewLocale(listen string, dialer Dialer) *Locale {
 	return &Locale{
-		Listen: listen,
 		Dialer: dialer,
+		Limits: rate.NewLimiter(rate.Inf, 0),
+		Listen: listen,
 	}
 }
 

protocol/ashe/engine.go

@@ -223,16 +223,16 @@ func (s *Server) Run() error {
 				}
 				break
 			}
-			rwc := &daze.RateConn{
-				Conn: cli,
-				Rate: s.Limits,
-			}
 			idx++
 			ctx := &daze.Context{Cid: idx}
 			log.Printf("conn: %08x accept remote=%s", ctx.Cid, cli.RemoteAddr())
+			rtc := &daze.RateConn{
+				Conn: cli,
+				Rate: s.Limits,
+			}
 			go func() {
-				defer cli.Close()
-				if err := s.Serve(ctx, rwc); err != nil {
+				defer rtc.Close()
+				if err := s.Serve(ctx, rtc); err != nil {
 					log.Printf("conn: %08x  error %s", ctx.Cid, err)
 				}
 				log.Printf("conn: %08x closed", ctx.Cid)
@@ -256,7 +256,6 @@ func NewServer(listen string, cipher string) *Server {
 type Client struct {
 	// Cipher is a pre-shared key.
 	Cipher []byte
-	Limits *rate.Limiter
 	Server string
 }
 
@@ -345,11 +344,7 @@ func (c *Client) Dial(ctx *daze.Context, network string, address string) (io.Rea
 	if err != nil {
 		return nil, err
 	}
-	rwc := &daze.RateConn{
-		Conn: srv,
-		Rate: c.Limits,
-	}
-	con, err := c.Estab(ctx, rwc, network, address)
+	con, err := c.Estab(ctx, srv, network, address)
 	if err != nil {
 		srv.Close()
 	}
@@ -360,7 +355,6 @@ func (c *Client) Dial(ctx *daze.Context, network string, address string) (io.Rea
 func NewClient(server, cipher string) *Client {
 	return &Client{
 		Cipher: daze.Salt(cipher),
-		Limits: rate.NewLimiter(rate.Inf, 0),
 		Server: server,
 	}
 }

protocol/baboon/engine.go

@@ -76,14 +76,14 @@ func (s *Server) ServeDaze(w http.ResponseWriter, r *http.Request) {
 		Writer: cc,
 		Closer: cc,
 	}
-	rwc := &daze.RateConn{
-		Conn: cli,
-		Rate: s.Limits,
-	}
 	spy := &ashe.Server{Cipher: s.Cipher}
 	ctx := &daze.Context{Cid: atomic.AddUint32(&s.NextID, 1)}
 	log.Printf("conn: %08x accept remote=%s", ctx.Cid, cc.RemoteAddr())
-	if err := spy.Serve(ctx, rwc); err != nil {
+	rtc := &daze.RateConn{
+		Conn: cli,
+		Rate: s.Limits,
+	}
+	if err := spy.Serve(ctx, rtc); err != nil {
 		log.Printf("conn: %08x  error %s", ctx.Cid, err)
 	}
 	log.Printf("conn: %08x closed", ctx.Cid)
@@ -159,7 +159,6 @@ func NewServer(listen string, cipher string) *Server {
 // Client implemented the baboon protocol.
 type Client struct {
 	Cipher []byte
-	Limits *rate.Limiter
 	Server string
 }
 
@@ -175,10 +174,6 @@ func (c *Client) Dial(ctx *daze.Context, network string, address string) (io.Rea
 	if err != nil {
 		return nil, err
 	}
-	srv = &daze.RateConn{
-		Conn: srv,
-		Rate: c.Limits,
-	}
 	buf = make([]byte, 32)
 	io.ReadFull(&daze.RandomReader{}, buf[:16])
 	copy(buf[16:], c.Cipher[:16])
@@ -202,7 +197,6 @@ func (c *Client) Dial(ctx *daze.Context, network string, address string) (io.Rea
 func NewClient(server string, cipher string) *Client {
 	return &Client{
 		Cipher: daze.Salt(cipher),
-		Limits: rate.NewLimiter(rate.Inf, 0),
 		Server: server,
 	}
 }

protocol/czar/engine.go

@@ -96,11 +96,11 @@ func (s *Server) Run() error {
 				}
 				break
 			}
-			rwc := &daze.RateConn{
+			rtc := &daze.RateConn{
 				Conn: cli,
 				Rate: s.Limits,
 			}
-			mux := NewMuxServer(rwc)
+			mux := NewMuxServer(rtc)
 			go func() {
 				defer mux.Close()
 				for con := range mux.Accept() {
@@ -135,7 +135,6 @@ func NewServer(listen string, cipher string) *Server {
 type Client struct {
 	Cancel chan struct{}
 	Cipher []byte
-	Limits *rate.Limiter
 	Mux    chan *Mux
 	Server string
 }
@@ -156,13 +155,9 @@ func (c *Client) Dial(ctx *daze.Context, network string, address string) (io.Rea
 		}
 		log.Printf("czar: mux slot stream id=0x%02x", srv.idx)
 		spy := &ashe.Client{Cipher: c.Cipher}
-		rwc := &daze.RateConn{
-			Conn: srv,
-			Rate: c.Limits,
-		}
-		con, err := spy.Estab(ctx, rwc, network, address)
+		con, err := spy.Estab(ctx, srv, network, address)
 		if err != nil {
-			rwc.Close()
+			srv.Close()
 		}
 		return con, err
 	case <-time.After(daze.Conf.DialerTimeout):
@@ -233,7 +228,6 @@ func NewClient(server, cipher string) *Client {
 	client := &Client{
 		Cancel: make(chan struct{}),
 		Cipher: daze.Salt(cipher),
-		Limits: rate.NewLimiter(rate.Inf, 0),
 		Mux:    make(chan *Mux),
 		Server: server,
 	}

protocol/dahlia/engine.go

@@ -147,16 +147,16 @@ func (c *Client) Run() error {
 				}
 				break
 			}
-			rwc := &daze.RateConn{
+			rtc := &daze.RateConn{
 				Conn: cli,
 				Rate: c.Limits,
 			}
 			idx++
 			ctx := &daze.Context{Cid: idx}
 			log.Printf("conn: %08x accept remote=%s", ctx.Cid, cli.RemoteAddr())
 			go func() {
-				defer cli.Close()
-				if err := c.Serve(ctx, rwc); err != nil {
+				defer rtc.Close()
+				if err := c.Serve(ctx, rtc); err != nil {
 					log.Printf("conn: %08x  error %s", ctx.Cid, err)
 				}
 				log.Printf("conn: %08x closed", ctx.Cid)