partial migration to errkit

Author: Mzack9999

cmd/tlsx/main.go

@@ -9,7 +9,8 @@ import (
 	"github.com/projectdiscovery/tlsx/internal/runner"
 	"github.com/projectdiscovery/tlsx/pkg/tlsx/clients"
 	"github.com/projectdiscovery/tlsx/pkg/tlsx/openssl"
-	errorutils "github.com/projectdiscovery/utils/errors"
+	"github.com/projectdiscovery/utils/errkit"
+	errorutils "github.com/projectdiscovery/utils/errors" //nolint
 	fileutil "github.com/projectdiscovery/utils/file"
 )
 
@@ -26,20 +27,20 @@ func main() {
 
 func process() error {
 	if err := readFlags(); err != nil {
-		return errorutils.NewWithErr(err).Msgf("could not read flags")
+		return errkit.Wrapf(err, "could not read flags")
 	}
 	runner, err := runner.New(options)
 	if err != nil {
-		return errorutils.NewWithErr(err).Msgf("could not create runner")
+		return errkit.Wrapf(err, "could not create runner")
 	}
 	if runner == nil {
 		return nil
 	}
 	if err := runner.Execute(); err != nil {
-		return errorutils.NewWithErr(err).Msgf("could not execute runner")
+		return errkit.Wrapf(err, "could not execute runner")
 	}
 	if err := runner.Close(); err != nil {
-		return errorutils.NewWithErr(err).Msgf("could not close runner")
+		return errkit.Wrapf(err, "could not close runner")
 	}
 	return nil
 }
@@ -154,13 +155,13 @@ func readFlags(args ...string) error {
 
 	err := flagSet.Parse(args...)
 	if err != nil {
-		return errorutils.NewWithErr(err).Msgf("could not parse flags")
+		return errkit.Wrapf(err, "could not parse flags")
 	}
 	hasStdin := fileutil.HasStdin()
 
 	// Validation: CT logs mode and input mode cannot be used together
 	if options.CTLogs && (len(options.Inputs) > 0 || options.InputList != "" || hasStdin) {
-		return errorutils.NewWithTag("flags", "CT logs mode (-ctl) and input mode (-u/-l/stdin) cannot be used together.")
+		return errorutils.NewWithTag("flags", "CT logs mode (-ctl) and input mode (-u/-l/stdin) cannot be used together.") //nolint
 	}
 
 	// Enable CT logs mode by default if no input is provided
@@ -180,7 +181,7 @@ func readFlags(args ...string) error {
 
 	if cfgFile != "" {
 		if err := flagSet.MergeConfigFile(cfgFile); err != nil {
-			return errorutils.NewWithErr(err).Msgf("could not read config file")
+			return errkit.Wrapf(err, "could not read config file")
 		}
 	}
 	return nil
@@ -190,6 +191,6 @@ func init() {
 	// Feature: Debug Mode
 	// Errors will include stacktrace when debug mode is enabled
 	if os.Getenv("DEBUG") != "" {
-		errorutils.ShowStackTrace = true
+		errkit.EnableTrace = true
 	}
 }

internal/runner/banner.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/projectdiscovery/gologger"
 	"github.com/projectdiscovery/gologger/levels"
-	errorutils "github.com/projectdiscovery/utils/errors"
+	"github.com/projectdiscovery/utils/errkit"
 	fileutil "github.com/projectdiscovery/utils/file"
 	updateutils "github.com/projectdiscovery/utils/update"
 )
@@ -33,10 +33,10 @@ func (r *Runner) validateOptions() error {
 	}
 	probeSpecified := r.options.SO || r.options.TLSVersion || r.options.Cipher || r.options.Expired || r.options.SelfSigned || r.options.Hash != "" || r.options.Jarm || r.options.MisMatched || r.options.Revoked || r.options.WildcardCertCheck
 	if r.options.RespOnly && probeSpecified {
-		return errorutils.New("resp-only flag can only be used with san and cn flags")
+		return errkit.New("resp-only flag can only be used with san and cn flags")
 	}
 	if (r.options.SAN || r.options.CN) && probeSpecified {
-		return errorutils.New("san or cn flag cannot be used with other probes")
+		return errkit.New("san or cn flag cannot be used with other probes")
 	}
 
 	// Enable CT logs mode by default if no input is provided
@@ -47,15 +47,15 @@ func (r *Runner) validateOptions() error {
 
 	// Check if we still have no input after auto-enabling CT logs
 	if !r.options.CTLogs && !r.hasStdin && len(r.options.Inputs) == 0 && r.options.InputList == "" {
-		return errorutils.New("no input provided for enumeration")
+		return errkit.New("no input provided for enumeration")
 	}
 
 	if len(r.options.Ports) == 0 {
 		// Append port 443 for default ports
 		r.options.Ports = append(r.options.Ports, "443")
 	}
 	if r.options.CertsOnly && (r.options.ScanMode != "ztls" && r.options.ScanMode != "auto") {
-		return errorutils.New("scan-mode must be ztls or auto with certs-only option")
+		return errkit.New("scan-mode must be ztls or auto with certs-only option")
 	}
 	if r.options.CertsOnly || r.options.Ja3 || r.options.Ja3s {
 		r.options.ScanMode = "ztls" // force setting ztls when using certs-only

internal/runner/runner.go

@@ -26,7 +26,7 @@ import (
 	"github.com/projectdiscovery/tlsx/pkg/tlsx"
 	"github.com/projectdiscovery/tlsx/pkg/tlsx/clients"
 	"github.com/projectdiscovery/tlsx/pkg/tlsx/openssl"
-	errorutil "github.com/projectdiscovery/utils/errors"
+	"github.com/projectdiscovery/utils/errkit" //nolint
 	iputil "github.com/projectdiscovery/utils/ip"
 	sliceutil "github.com/projectdiscovery/utils/slice"
 	updateutils "github.com/projectdiscovery/utils/update"
@@ -79,7 +79,7 @@ func New(options *clients.Options) (*Runner, error) {
 
 	runner := &Runner{options: options}
 	if err := runner.validateOptions(); err != nil {
-		return nil, errorutil.NewWithErr(err).Msgf("could not validate options")
+		return nil, errkit.Wrap(err, "could not validate options")
 	}
 
 	dialerTimeout := time.Duration(options.Timeout) * time.Second
@@ -88,14 +88,14 @@ func New(options *clients.Options) (*Runner, error) {
 	if options.Proxy != "" {
 		proxyURL, err := url.Parse(options.Proxy)
 		if err != nil {
-			return nil, errorutil.NewWithErr(err).Msgf("could not parse proxy")
+			return nil, errkit.Wrap(err, "could not parse proxy")
 		}
 		dialer, err := proxy.FromURL(proxyURL, &net.Dialer{
 			Timeout:   dialerTimeout,
 			DualStack: true,
 		})
 		if err != nil {
-			return nil, errorutil.NewWithErr(err).Msgf("could not create proxy dialer")
+			return nil, errkit.Wrap(err, "could not create proxy dialer")
 		}
 		proxyDialer = &dialer
 	}
@@ -112,7 +112,7 @@ func New(options *clients.Options) (*Runner, error) {
 	}
 	fastDialer, err := fastdialer.NewDialer(dialerOpts)
 	if err != nil {
-		return nil, errorutil.NewWithErr(err).Msgf("could not create dialer")
+		return nil, errkit.Wrap(err, "could not create dialer")
 	}
 	runner.fastDialer = fastDialer
 	runner.options.Fastdialer = fastDialer
@@ -131,7 +131,7 @@ func New(options *clients.Options) (*Runner, error) {
 
 	outputWriter, err := output.New(options)
 	if err != nil {
-		return nil, errorutil.NewWithErr(err).Msgf("could not create output writer")
+		return nil, errkit.Wrap(err, "could not create output writer")
 	}
 	runner.outputWriter = outputWriter
 	if options.TlsCiphersEnum && !options.Silent {
@@ -244,7 +244,7 @@ func (r *Runner) executeCTLogsMode() error {
 		// Display CT log progress information in verbose mode
 		if r.options.Verbose {
 			progressPercent := float64(meta.Index) / float64(meta.TreeSize) * 100
-			gologger.Info().Msgf("[CT] %s: Index %d/%d (%.1f%%), Lag: %d, URL: %s", 
+			gologger.Info().Msgf("[CT] %s: Index %d/%d (%.1f%%), Lag: %d, URL: %s",
 				meta.SourceDesc, meta.Index, meta.TreeSize, progressPercent, meta.Lag, meta.LogURL)
 		}
 
@@ -267,7 +267,7 @@ func (r *Runner) executeCTLogsMode() error {
 
 	ctService, err := ctlogs.New(svcOpts...)
 	if err != nil {
-		return errorutil.NewWithErr(err).Msgf("could not create CT logs service")
+		return errkit.Wrap(err, "could not create CT logs service")
 	}
 
 	// Start streaming
@@ -326,7 +326,7 @@ func (r *Runner) normalizeAndQueueInputs(inputs chan taskInput) error {
 	if r.options.InputList != "" {
 		file, err := os.Open(r.options.InputList)
 		if err != nil {
-			return errorutil.NewWithErr(err).Msgf("could not open input file")
+			return errkit.Wrap(err, "could not open input file")
 		}
 		defer func() {
 			if err := file.Close(); err != nil {

pkg/output/output.go

@@ -11,7 +11,7 @@ import (
 	jsoniter "github.com/json-iterator/go"
 	"github.com/logrusorgru/aurora"
 	"github.com/projectdiscovery/tlsx/pkg/tlsx/clients"
-	errorutil "github.com/projectdiscovery/utils/errors"
+	"github.com/projectdiscovery/utils/errkit" //nolint
 	mapsutil "github.com/projectdiscovery/utils/maps"
 	"golang.org/x/exp/maps"
 )
@@ -50,7 +50,7 @@ func New(options *clients.Options) (Writer, error) {
 	if options.OutputFile != "" {
 		output, err := newFileOutputWriter(options.OutputFile)
 		if err != nil {
-			return nil, errorutil.NewWithErr(err).Msgf("could not create output file")
+			return nil, errkit.Wrap(err, "could not create output file")
 		}
 		outputFile = output
 	}
@@ -75,7 +75,7 @@ func (w *StandardWriter) Write(event *clients.Response) error {
 		data, err = w.formatStandard(event)
 	}
 	if err != nil {
-		return errorutil.NewWithErr(err).Msgf("could not format output")
+		return errkit.Wrap(err, "could not format output")
 	}
 	data = bytes.TrimSuffix(data, []byte("\n")) // remove last newline
 	if len(data) == 0 {
@@ -92,7 +92,7 @@ func (w *StandardWriter) Write(event *clients.Response) error {
 			data = decolorizerRegex.ReplaceAll(data, []byte(""))
 		}
 		if writeErr := w.outputFile.Write(data); writeErr != nil {
-			return errorutil.NewWithErr(err).Msgf("could not write to output")
+			return errkit.Wrap(err, "could not write to output")
 		}
 	}
 	return nil
@@ -115,11 +115,11 @@ func (w *StandardWriter) formatJSON(output *clients.Response) ([]byte, error) {
 // formatStandard formats the output for standard client formatting
 func (w *StandardWriter) formatStandard(output *clients.Response) ([]byte, error) {
 	if output == nil {
-		return nil, errorutil.New("empty certificate response")
+		return nil, errkit.New("empty certificate response")
 	}
 
 	if output.CertificateResponse == nil {
-		return nil, errorutil.New("empty leaf certificate")
+		return nil, errkit.New("empty leaf certificate")
 	}
 	cert := output.CertificateResponse
 	builder := &bytes.Buffer{}

pkg/tlsx/auto/auto.go

@@ -10,7 +10,8 @@ import (
 	"github.com/projectdiscovery/tlsx/pkg/tlsx/openssl"
 	"github.com/projectdiscovery/tlsx/pkg/tlsx/tls"
 	"github.com/projectdiscovery/tlsx/pkg/tlsx/ztls"
-	errorutils "github.com/projectdiscovery/utils/errors"
+	"github.com/projectdiscovery/utils/errkit"
+	errorutils "github.com/projectdiscovery/utils/errors" //nolint
 	sliceutil "github.com/projectdiscovery/utils/slice"
 	"go.uber.org/multierr"
 )
@@ -29,7 +30,7 @@ func New(options *clients.Options) (*Client, error) {
 	ztlsClient, ztlsErr := ztls.New(options)
 	opensslClient, opensslErr := openssl.New(options)
 
-	if tlsErr != nil && ztlsErr != nil && (opensslErr != nil && !errorutils.IsAny(opensslErr, openssl.ErrNotAvailable)) {
+	if tlsErr != nil && ztlsErr != nil && (opensslErr != nil && !errorutils.IsAny(opensslErr, openssl.ErrNotAvailable)) { //nolint
 		return nil, multierr.Combine(tlsErr, ztlsErr, opensslErr)
 	}
 	return &Client{tlsClient: tlsClient, ztlsClient: ztlsClient, opensslClient: opensslClient, options: options}, nil
@@ -46,7 +47,7 @@ func (c *Client) ConnectWithOptions(hostname, ip, port string, options clients.C
 	retryCounter := 0
 	if c.tlsClient == nil && c.ztlsClient == nil && c.opensslClient == nil {
 		// logic to avoid infinite loop
-		return nil, errorutils.New("no tls client available available for auto mode")
+		return nil, errkit.New("no tls client available available for auto mode")
 	}
 	var errStack error
 	for retryCounter < maxRetries {
@@ -72,7 +73,7 @@ func (c *Client) ConnectWithOptions(hostname, ip, port string, options clients.C
 				stats.IncrementOpensslTLSConnections()
 				return response, nil
 			}
-			if errorutils.IsAny(opensslErr, openssl.ErrNotAvailable) {
+			if errorutils.IsAny(opensslErr, openssl.ErrNotAvailable) { //nolint
 				opensslErr = nil
 			}
 			retryCounter++

pkg/tlsx/clients/utils.go

@@ -10,7 +10,7 @@ import (
 	"strings"
 	"time"
 
-	errorutil "github.com/projectdiscovery/utils/errors"
+	"github.com/projectdiscovery/utils/errkit"
 	iputil "github.com/projectdiscovery/utils/ip"
 	mapsutil "github.com/projectdiscovery/utils/maps"
 )
@@ -102,14 +102,14 @@ func GetConn(ctx context.Context, hostname, ip, port string, inputOpts *Options)
 	}
 	//validation
 	if (hostname == "" && ip == "") || port == "" {
-		return nil, errorutil.New("client requires valid address got port=%v,hostname=%v,ip=%v", port, hostname, ip)
+		return nil, errkit.Newf("client requires valid address got port=%v,hostname=%v,ip=%v", port, hostname, ip)
 	}
 	rawConn, err := inputOpts.Fastdialer.Dial(ctx, "tcp", address)
 	if err != nil {
-		return nil, errorutil.New("could not dial address").Wrap(err)
+		return nil, errkit.Wrap(err, "could not dial address")
 	}
 	if rawConn == nil {
-		return nil, errorutil.New("could not connect to %s", address)
+		return nil, errkit.Newf("could not connect to %s", address)
 	}
 	if inputOpts.Timeout == 0 {
 		inputOpts.Timeout = 5

pkg/tlsx/openssl/common.go

@@ -9,15 +9,15 @@ import (
 	"strings"
 
 	"github.com/projectdiscovery/gologger"
-	errorutils "github.com/projectdiscovery/utils/errors"
+	errorutils "github.com/projectdiscovery/utils/errors" //nolint
 )
 
 var (
-	ErrParse          = errorutils.NewWithTag("openssl", "failed to parse openssl response")
-	ErrCertParse      = errorutils.NewWithTag("openssl", "failed to parse server certificate")
-	ErrNotImplemented = errorutils.NewWithTag("openssl", "feature not implemented")
-	ErrNotAvailable   = errorutils.NewWithTag("openssl", "executable not installed or in PATH")
-	ErrNoSession      = errorutils.NewWithTag("openssl", "session not created/found")
+	ErrParse          = errorutils.NewWithTag("openssl", "failed to parse openssl response")    //nolint
+	ErrCertParse      = errorutils.NewWithTag("openssl", "failed to parse server certificate")  //nolint
+	ErrNotImplemented = errorutils.NewWithTag("openssl", "feature not implemented")             //nolint
+	ErrNotAvailable   = errorutils.NewWithTag("openssl", "executable not installed or in PATH") //nolint
+	ErrNoSession      = errorutils.NewWithTag("openssl", "session not created/found")           //nolint
 )
 
 var (
@@ -55,19 +55,19 @@ func init() {
 		return
 	}
 	if err := openSSLSetup(); err != nil {
-		gologger.Debug().Label("openssl").Msg(err.Error())
+		gologger.Debug().Label("openssl").Msg(err.Error()) //nolint
 	}
 }
 
 // fetch openssl version
-func openSSLSetup() errorutils.Error {
+func openSSLSetup() errorutils.Error { //nolint
 	result, err := execOpenSSL(context.TODO(), []string{"version"})
 	if err != nil {
-		return errorutils.NewWithErr(err).WithTag("openssl").Msgf(result.Stderr)
+		return errorutils.NewWithErr(err).WithTag("openssl").Msgf(result.Stderr) //nolint
 	}
 	arr := strings.Fields(result.Stdout)
 	if len(arr) < 2 {
-		return errorutils.NewWithTag("openssl", "failed to parse openssl version got %v", result.Stdout)
+		return errorutils.NewWithTag("openssl", "failed to parse openssl version got %v", result.Stdout) //nolint
 	}
 	if arr[0] == "LibreSSL" {
 		IsLibreSSL = true
@@ -100,6 +100,6 @@ func UseOpenSSLBinary(binpath string) {
 	BinaryPath = binpath
 	if err := openSSLSetup(); err != nil {
 		// do not fallback
-		gologger.Fatal().Label("openssl").Msg(err.Error())
+		gologger.Fatal().Label("openssl").Msg(err.Error()) //nolint
 	}
 }