multiple bug fixes + performance improvements (#5148)

* prototype errkit

* complete errkit implementation

* add cause to all timeouts

* fix request timeout annotation @timeout

* increase responseHeaderTimeout to 8 for stability

* rawhttp error related improvements

* feat: add port status caching

* add port status caching to http

* migrate to new utils/errkit

* remote dialinterface + error cause

* debug dir support using .gitignore debug-*

* make nuclei easy to debug

* debug dir update .gitignore

* temp change (to revert)

* Revert "temp change (to revert)"

This reverts commit d3131f7777.

* use available context instead of new one

* bump fastdialer

* fix hosterrorscache + misc improvements

* add 'address' field in error log

* fix js vague errors + pgwrap driver

* fix max host error + misc updates

* update tests as per changes

* fix request annotation context

* remove closed dialer reference

* fix sdk panic issue

* bump retryablehttp-go,utils,fastdialer

---------

Co-authored-by: Sandeep Singh <sandeep@projectdiscovery.io>

pkg/protocols/common/hosterrorscache/hosterrorscache_test.go

@@ -1,11 +1,13 @@
 package hosterrorscache
 
 import (
+	"context"
 	"fmt"
 	"sync"
 	"sync/atomic"
 	"testing"
 
+	"github.com/projectdiscovery/nuclei/v3/pkg/protocols/common/contextargs"
 	"github.com/stretchr/testify/require"
 )
 
@@ -13,8 +15,8 @@ func TestCacheCheck(t *testing.T) {
 	cache := New(3, DefaultMaxHostsCount, nil)
 
 	for i := 0; i < 100; i++ {
-		cache.MarkFailed("test", fmt.Errorf("could not resolve host"))
-		got := cache.Check("test")
+		cache.MarkFailed(newCtxArgs("test"), fmt.Errorf("could not resolve host"))
+		got := cache.Check(newCtxArgs("test"))
 		if i < 2 {
 			// till 3 the host is not flagged to skip
 			require.False(t, got)
@@ -24,7 +26,7 @@ func TestCacheCheck(t *testing.T) {
 		}
 	}
 
-	value := cache.Check("test")
+	value := cache.Check(newCtxArgs("test"))
 	require.Equal(t, true, value, "could not get checked value")
 }
 
@@ -32,8 +34,8 @@ func TestTrackErrors(t *testing.T) {
 	cache := New(3, DefaultMaxHostsCount, []string{"custom error"})
 
 	for i := 0; i < 100; i++ {
-		cache.MarkFailed("custom", fmt.Errorf("got: nested: custom error"))
-		got := cache.Check("custom")
+		cache.MarkFailed(newCtxArgs("custom"), fmt.Errorf("got: nested: custom error"))
+		got := cache.Check(newCtxArgs("custom"))
 		if i < 2 {
 			// till 3 the host is not flagged to skip
 			require.False(t, got)
@@ -42,7 +44,7 @@ func TestTrackErrors(t *testing.T) {
 			require.True(t, got)
 		}
 	}
-	value := cache.Check("custom")
+	value := cache.Check(newCtxArgs("custom"))
 	require.Equal(t, true, value, "could not get checked value")
 }
 
@@ -73,16 +75,18 @@ func TestCacheMarkFailed(t *testing.T) {
 
 	tests := []struct {
 		host     string
-		expected int
+		expected int32
 	}{
 		{"http://example.com:80", 1},
 		{"example.com:80", 2},
-		{"example.com", 1},
+		// earlier if port is not provided then port was omitted
+		// but from now it will default to appropriate http scheme based port with 80 as default
+		{"example.com:443", 1},
 	}
 
 	for _, test := range tests {
-		normalizedCacheValue := cache.normalizeCacheValue(test.host)
-		cache.MarkFailed(test.host, fmt.Errorf("no address found for host"))
+		normalizedCacheValue := cache.GetKeyFromContext(newCtxArgs(test.host), nil)
+		cache.MarkFailed(newCtxArgs(test.host), fmt.Errorf("no address found for host"))
 		failedTarget, err := cache.failedTargets.Get(normalizedCacheValue)
 		require.Nil(t, err)
 		require.NotNil(t, failedTarget)
@@ -102,7 +106,7 @@ func TestCacheMarkFailedConcurrent(t *testing.T) {
 	}{
 		{"http://example.com:80", 200},
 		{"example.com:80", 200},
-		{"example.com", 100},
+		{"example.com:443", 100},
 	}
 
 	// the cache is not atomic during items creation, so we pre-create them with counter to zero
@@ -120,14 +124,14 @@ func TestCacheMarkFailedConcurrent(t *testing.T) {
 			wg.Add(1)
 			go func() {
 				defer wg.Done()
-				cache.MarkFailed(currentTest.host, fmt.Errorf("could not resolve host"))
+				cache.MarkFailed(newCtxArgs(currentTest.host), fmt.Errorf("could not resolve host"))
 			}()
 		}
 	}
 	wg.Wait()
 
 	for _, test := range tests {
-		require.True(t, cache.Check(test.host))
+		require.True(t, cache.Check(newCtxArgs(test.host)))
 
 		normalizedCacheValue := cache.normalizeCacheValue(test.host)
 		failedTarget, err := cache.failedTargets.Get(normalizedCacheValue)
@@ -139,3 +143,8 @@ func TestCacheMarkFailedConcurrent(t *testing.T) {
 		require.EqualValues(t, test.expected, value.errors.Load())
 	}
 }
+
+func newCtxArgs(value string) *contextargs.Context {
+	ctx := contextargs.NewWithInput(context.TODO(), value)
+	return ctx
+}