fix: prevent send-on-closed-channel panic and baseline invalid on raw parse failure

- Replace close(additionCh) with additionClosed atomic.Bool flag to
  prevent panic when async producers (redirect/crawl/retry/append)
  write after pool shutdown
- Guard addAddition() with ctx.Err() and additionClosed check before send
- ParseRawResponse failure no longer marks baseline as invalid or
  returns early; log at debug level instead
- Read Location header from live response (resp.GetHeader) instead of
  re-parsed bl.Response.Header for reliability
- Add ParseRawResponse boundary tests (nil, empty, truncated, binary, etc.)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: M09Ic

core/baseline/baseline.go

@@ -3,6 +3,7 @@ package baseline
 import (
 	"bytes"
 	"github.com/chainreactors/fingers/common"
+	"github.com/chainreactors/logs"
 	"github.com/chainreactors/parsers"
 	"github.com/chainreactors/spray/core/ihttp"
 	"github.com/chainreactors/spray/pkg"
@@ -53,15 +54,14 @@ func NewBaseline(u, host string, resp *ihttp.Response) *Baseline {
 	bl.Raw = append(bl.Header, bl.Body...)
 	bl.Response, err = pkg.ParseRawResponse(bl.Raw)
 	if err != nil {
-		bl.IsValid = false
-		bl.Reason = pkg.ErrResponseError.Error()
-		bl.ErrString = err.Error()
-		return bl
+		// raw 重解析失败不影响 baseline 有效性，live response 已提供所有需要的数据
+		logs.Log.Debugf("ParseRawResponse failed for %s: %s", u, err.Error())
 	}
-	if r := bl.Response.Header.Get("Location"); r != "" {
+	// 始终从 live response 读取 Location
+	if r := resp.GetHeader("Location"); r != "" {
 		bl.RedirectURL = r
 	} else {
-		bl.RedirectURL = bl.Response.Header.Get("location")
+		bl.RedirectURL = resp.GetHeader("location")
 	}
 
 	bl.Dir = bl.IsDir()

core/pool/brutepool.go

@@ -678,8 +678,9 @@ func (pool *BrutePool) Close() {
 		// 等待缓存的待处理任务完成
 		time.Sleep(time.Duration(100) * time.Millisecond)
 	}
-	close(pool.additionCh) // 关闭addition管道
-	//close(pool.checkCh)    // 关闭check管道
+	pool.additionClosed.Store(true)
+	// additionCh 可能仍有异步 producer（redirect/crawl/retry/append），
+	// 依赖 closeCh/ctx 停止消费循环，不直接关闭 channel
 	pool.Statistor.EndTime = time.Now().Unix()
 	pool.reqPool.Release()
 	pool.scopePool.Release()

core/pool/pool.go

@@ -21,12 +21,13 @@ type BasePool struct {
 	ctx       context.Context
 	processCh chan *baseline.Baseline // 待处理的baseline
 
-	reqCount    int
-	failedCount int
-	additionCh  chan *Unit
-	closeCh     chan struct{}
-	wg          *sync.WaitGroup
-	isFallback  atomic.Bool
+	reqCount       int
+	failedCount    int
+	additionCh     chan *Unit
+	additionClosed atomic.Bool
+	closeCh        chan struct{}
+	wg             *sync.WaitGroup
+	isFallback     atomic.Bool
 }
 
 func (pool *BasePool) doRetry(bl *baseline.Baseline) {
@@ -44,11 +45,18 @@ func (pool *BasePool) doRetry(bl *baseline.Baseline) {
 }
 
 func (pool *BasePool) addAddition(u *Unit) {
+	if pool.ctx.Err() != nil || pool.additionClosed.Load() {
+		return
+	}
+
 	pool.wg.Add(1)
 	select {
+	case <-pool.ctx.Done():
+		pool.wg.Done()
+		return
 	case pool.additionCh <- u:
+		return
 	default:
-		// 强行屏蔽报错, 防止goroutine泄露
 		go func() {
 			select {
 			case pool.additionCh <- u:

pkg/utils_test.go

@@ -0,0 +1,122 @@
+package pkg
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestParseRawResponse(t *testing.T) {
+	t.Run("valid complete response", func(t *testing.T) {
+		raw := "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: 5\r\n\r\nhello"
+		resp, err := ParseRawResponse([]byte(raw))
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if resp.StatusCode != 200 {
+			t.Fatalf("expected status 200, got %d", resp.StatusCode)
+		}
+		if ct := resp.Header.Get("Content-Type"); ct != "text/html" {
+			t.Fatalf("expected Content-Type text/html, got %s", ct)
+		}
+	})
+
+	t.Run("nil input", func(t *testing.T) {
+		_, err := ParseRawResponse(nil)
+		if err == nil {
+			t.Fatal("expected error for nil input")
+		}
+	})
+
+	t.Run("empty input", func(t *testing.T) {
+		_, err := ParseRawResponse([]byte{})
+		if err == nil {
+			t.Fatal("expected error for empty input")
+		}
+	})
+
+	t.Run("status line only no headers", func(t *testing.T) {
+		raw := "HTTP/1.1 200 OK\r\n\r\n"
+		resp, err := ParseRawResponse([]byte(raw))
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if resp.StatusCode != 200 {
+			t.Fatalf("expected status 200, got %d", resp.StatusCode)
+		}
+	})
+
+	t.Run("truncated status line", func(t *testing.T) {
+		raw := "HTTP/1."
+		_, err := ParseRawResponse([]byte(raw))
+		if err == nil {
+			t.Fatal("expected error for truncated status line")
+		}
+	})
+
+	t.Run("redirect response no body", func(t *testing.T) {
+		raw := "HTTP/1.1 302 Found\r\nLocation: https://example.com/new\r\n\r\n"
+		resp, err := ParseRawResponse([]byte(raw))
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if resp.StatusCode != 302 {
+			t.Fatalf("expected status 302, got %d", resp.StatusCode)
+		}
+		if loc := resp.Header.Get("Location"); loc != "https://example.com/new" {
+			t.Fatalf("expected Location https://example.com/new, got %s", loc)
+		}
+	})
+
+	t.Run("chunked transfer encoding header", func(t *testing.T) {
+		raw := "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"
+		resp, err := ParseRawResponse([]byte(raw))
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if te := resp.Header.Get("Transfer-Encoding"); te == "" {
+			// Transfer-Encoding may be consumed by http.ReadResponse, just verify no panic
+		}
+		_ = resp
+	})
+
+	t.Run("large header value", func(t *testing.T) {
+		largeValue := strings.Repeat("A", 8192)
+		raw := "HTTP/1.1 200 OK\r\nX-Large: " + largeValue + "\r\n\r\n"
+		resp, err := ParseRawResponse([]byte(raw))
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if got := resp.Header.Get("X-Large"); got != largeValue {
+			t.Fatalf("large header value mismatch, got length %d", len(got))
+		}
+	})
+
+	t.Run("invalid status code", func(t *testing.T) {
+		raw := "HTTP/1.1 xyz OK\r\n\r\n"
+		_, err := ParseRawResponse([]byte(raw))
+		if err == nil {
+			t.Fatal("expected error for invalid status code")
+		}
+	})
+
+	t.Run("incomplete header no terminator", func(t *testing.T) {
+		raw := "HTTP/1.1 200 OK\r\nContent-Type: text/html"
+		_, err := ParseRawResponse([]byte(raw))
+		// Should return error or at least not panic
+		// http.ReadResponse may or may not error on missing \r\n\r\n,
+		// the key requirement is no panic
+		_ = err
+	})
+
+	t.Run("binary body", func(t *testing.T) {
+		body := []byte{0x00, 0x01, 0x02, 0xff, 0xfe, 0xfd}
+		raw := append([]byte("HTTP/1.1 200 OK\r\nContent-Length: 6\r\n\r\n"), body...)
+		resp, err := ParseRawResponse(raw)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if resp.StatusCode != 200 {
+			t.Fatalf("expected status 200, got %d", resp.StatusCode)
+		}
+	})
+}