Merge pull request #7298 from projectdiscovery/7295-dynamic-auth-flow-fix

fixing flow with auth

Author: dogancanbakir

internal/runner/lazy.go

@@ -109,11 +109,9 @@ func GetLazyAuthFetchCallback(opts *AuthLazyFetchOptions) authx.LazyFetchSecret
 		var finalErr error
 		ctx.OnResult = func(e *output.InternalWrappedEvent) {
 			if e == nil {
-				finalErr = fmt.Errorf("no result found for template: %s", d.TemplatePath)
 				return
 			}
 			if !e.HasOperatorResult() {
-				finalErr = fmt.Errorf("no result found for template: %s", d.TemplatePath)
 				return
 			}
 			// dynamic values
@@ -133,20 +131,16 @@ func GetLazyAuthFetchCallback(opts *AuthLazyFetchOptions) authx.LazyFetchSecret
 					data[k] = v[0]
 				}
 			}
-			if len(data) == 0 {
-				if e.OperatorsResult.Matched {
-					finalErr = fmt.Errorf("match found but no (dynamic/extracted) values found for template: %s", d.TemplatePath)
-				} else {
-					finalErr = fmt.Errorf("no match or (dynamic/extracted) values found for template: %s", d.TemplatePath)
-				}
-			}
 			// log result of template in result file/screen
 			_ = writer.WriteResult(e, opts.ExecOpts.Output, opts.ExecOpts.Progress, opts.ExecOpts.IssuesClient)
 		}
 		_, execErr := tmpl.Executer.ExecuteWithResults(ctx)
 		if execErr != nil {
 			finalErr = execErr
 		}
+		if finalErr == nil && len(data) == 0 {
+			finalErr = fmt.Errorf("no extracted values found for template: %s", d.TemplatePath)
+		}
 		// store extracted result in auth context
 		d.Extracted = data
 		if finalErr != nil && opts.OnError != nil {

internal/runner/lazy_test.go

@@ -0,0 +1,139 @@
+package runner
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/projectdiscovery/nuclei/v3/pkg/operators"
+	"github.com/projectdiscovery/nuclei/v3/pkg/output"
+	"github.com/stretchr/testify/require"
+)
+
+// simulateOnResultCallback reproduces the OnResult callback from lazy.go.
+// It silently skips events without operator results and only errors post-execution
+// if no data was extracted at all.
+func simulateOnResultCallback(templatePath string, events []*output.InternalWrappedEvent) (map[string]interface{}, error) {
+	data := map[string]interface{}{}
+
+	for _, e := range events {
+		if e == nil {
+			continue
+		}
+		if !e.HasOperatorResult() {
+			continue
+		}
+		for k, v := range e.OperatorsResult.DynamicValues {
+			for _, value := range v {
+				oldVal, ok := data[k]
+				if !ok || len(value) > len(oldVal.(string)) {
+					data[k] = value
+				}
+			}
+		}
+		for k, v := range e.OperatorsResult.Extracts {
+			if len(v) > 0 {
+				data[k] = v[0]
+			}
+		}
+	}
+
+	var finalErr error
+	if len(data) == 0 {
+		finalErr = fmt.Errorf("no extracted values found for template: %s", templatePath)
+	}
+	return data, finalErr
+}
+
+// flowEvents returns a pair of events simulating a flow: http(1) && http(2)
+// where http(1) has no matchers and http(2) has extractors.
+func flowEvents() []*output.InternalWrappedEvent {
+	return []*output.InternalWrappedEvent{
+		{InternalEvent: map[string]interface{}{"status_code": 200}},
+		{
+			OperatorsResult: &operators.Result{
+				Matched: true,
+				Extracts: map[string][]string{
+					"userid":     {"USER-042"},
+					"customerid": {"CUST-001"},
+				},
+			},
+			InternalEvent: map[string]interface{}{"status_code": 200},
+		},
+	}
+}
+
+// TestCallbackWorksWithFlowTemplate verifies that the OnResult callback
+// correctly handles flow templates (e.g., flow: http(1) && http(2)) where
+// the first request has no matchers/extractors and the second has extractors.
+// Regression test for #7295.
+func TestCallbackWorksWithFlowTemplate(t *testing.T) {
+	data, err := simulateOnResultCallback("login.yaml", flowEvents())
+
+	require.Equal(t, "USER-042", data["userid"])
+	require.Equal(t, "CUST-001", data["customerid"])
+	require.NoError(t, err, "should not error when data is extracted from a later event")
+}
+
+// TestCallbackSingleRequest verifies single-request templates still work.
+func TestCallbackSingleRequest(t *testing.T) {
+	events := []*output.InternalWrappedEvent{
+		{
+			OperatorsResult: &operators.Result{
+				Matched: true,
+				Extracts: map[string][]string{
+					"token": {"abc123"},
+				},
+			},
+			InternalEvent: map[string]interface{}{},
+		},
+	}
+
+	data, err := simulateOnResultCallback("auth.yaml", events)
+
+	require.NoError(t, err)
+	require.Equal(t, "abc123", data["token"])
+}
+
+// TestCallbackNoExtraction verifies error is returned when nothing is extracted.
+func TestCallbackNoExtraction(t *testing.T) {
+	events := []*output.InternalWrappedEvent{
+		{InternalEvent: map[string]interface{}{"status_code": 404}},
+	}
+
+	data, err := simulateOnResultCallback("auth.yaml", events)
+
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "no extracted values")
+	require.Empty(t, data)
+}
+
+// TestCallbackNilEvent verifies nil events are safely ignored.
+func TestCallbackNilEvent(t *testing.T) {
+	events := []*output.InternalWrappedEvent{nil}
+
+	data, err := simulateOnResultCallback("auth.yaml", events)
+
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "no extracted values")
+	require.Empty(t, data)
+}
+
+// TestCallbackDynamicValues verifies dynamic values (internal extractors) are captured.
+func TestCallbackDynamicValues(t *testing.T) {
+	events := []*output.InternalWrappedEvent{
+		{
+			OperatorsResult: &operators.Result{
+				Matched: true,
+				DynamicValues: map[string][]string{
+					"session": {"sess-xyz-123", "sess-a"},
+				},
+			},
+			InternalEvent: map[string]interface{}{},
+		},
+	}
+
+	data, err := simulateOnResultCallback("auth.yaml", events)
+
+	require.NoError(t, err)
+	require.Equal(t, "sess-xyz-123", data["session"], "should pick the longest value")
+}