added kasada support for capsolver.com

Author: ghaph

README.md

@@ -9,16 +9,17 @@ go get github.com/median/captchago
 ```
 
 ## Supported Services
-- [x] [2captcha (ruCaptcha)](https://2captcha.com)
 - [x] [AntiCaptcha](http://getcaptchasolution.com/ielxn7dpk3)
+- [x] [CapSolver](https://dashboard.capsolver.com/passport/register?inviteCode=G0LMAKBIuoJp)
 - [x] [CapMonster](https://capmonster.cloud)
+- [x] [2captcha (ruCaptcha)](https://2captcha.com)
 - [x] [AnyCaptcha](https://anycaptcha.com)
-- [x] [CapSolver](https://capsolver.com)
 - [x] Any other services that use the same API format as one above
 
 ## Methods
 - [x] Recaptcha V2
 - [x] Recaptcha V3
 - [x] HCaptcha
 - [x] FunCaptcha
+- [x] Kasada Anti-Bot ([CapSolver](https://dashboard.capsolver.com/passport/register?inviteCode=G0LMAKBIuoJp) only)
 - [x] Get Balance

acmethods.go

@@ -38,6 +38,8 @@ func antiCaptchaMethods(solver *Solver, preferredDomain string) *solveMethods {
 			payload["softId"] = 1080
 		} else if strings.Contains(d, "capmonster.cloud") {
 			payload["softId"] = 59
+		} else if strings.Contains(d, "capsolver.com") {
+			payload["appId"] = "B7E57F27-0AD3-434D-A5B7-CF9EE7D093EF"
 		}
 
 		body, err := postJSON(d+"/createTask", payload)
@@ -93,16 +95,20 @@ func antiCaptchaMethods(solver *Solver, preferredDomain string) *solveMethods {
 			case "processing":
 				continue
 			case "ready":
-				solution, hasSolution := body["solution"]
+				solution, hasSolution := body["solution"].(map[string]interface{})
 				if !hasSolution {
 					return nil, errors.New("no solution")
 				}
 
 				// response can either be gRecaptchaResponse or token
-				response := solution.(map[string]interface{})["gRecaptchaResponse"]
+				response := solution["gRecaptchaResponse"]
 
 				if response == nil {
-					response = solution.(map[string]interface{})["token"]
+					response = solution["token"]
+				}
+
+				if response == nil {
+					response = solution["x-kpsdk-ct"]
 				}
 
 				if response == nil {
@@ -127,10 +133,11 @@ func antiCaptchaMethods(solver *Solver, preferredDomain string) *solveMethods {
 				}
 
 				return &Solution{
-					TaskId: taskId,
-					Text:   response.(string),
-					IP:     ip,
-					Cost:   cost,
+					TaskId:      taskId,
+					Text:        response.(string),
+					RawSolution: solution,
+					IP:          ip,
+					Cost:        cost,
 				}, nil
 			default:
 				return nil, errors.New("unknown status")
@@ -183,7 +190,7 @@ func antiCaptchaMethods(solver *Solver, preferredDomain string) *solveMethods {
 		data["proxyType"] = t
 	}
 
-	return &solveMethods{
+	methods := &solveMethods{
 		GetBalance: func() (float64, error) {
 			d := domain()
 
@@ -317,4 +324,55 @@ func antiCaptchaMethods(solver *Solver, preferredDomain string) *solveMethods {
 			return createResponse(taskData)
 		},
 	}
+
+	// kasada method
+	if solver.service == CapSolver {
+		methods.Kasada = func(o KasadaOptions) (*KasadaSolution, error) {
+			taskData := map[string]interface{}{
+				"type":      "AntiKasadaTask",
+				"pageURL":   o.PageURL,
+				"cd":        o.DetailedCD,
+				"onlyCD":    o.OnlyCD,
+				"version":   o.Version,
+				"userAgent": o.UserAgent,
+			}
+
+			if o.Proxy != nil {
+				taskData["proxy"] = o.Proxy.String()
+			}
+
+			sol, err := createResponse(taskData)
+			if err != nil {
+				return nil, err
+			}
+
+			kpsdkCD := ""
+			kpsdkCT := ""
+			userAgent := ""
+
+			raw := sol.RawSolution["x-kpsdk-cd"]
+			if raw != nil {
+				kpsdkCD = raw.(string)
+			}
+
+			raw = sol.RawSolution["x-kpsdk-ct"]
+			if raw != nil {
+				kpsdkCT = raw.(string)
+			}
+
+			raw = sol.RawSolution["user-agent"]
+			if raw != nil {
+				userAgent = raw.(string)
+			}
+
+			return &KasadaSolution{
+				Solution:  sol,
+				KpsdkCD:   kpsdkCD,
+				KpsdkCT:   kpsdkCT,
+				UserAgent: userAgent,
+			}, nil
+		}
+	}
+
+	return methods
 }

captchas.go

@@ -10,6 +10,7 @@ type solveMethods struct {
 	RecaptchaV3 func(RecaptchaV3Options) (*Solution, error)
 	HCaptcha    func(HCaptchaOptions) (*Solution, error)
 	FunCaptcha  func(FunCaptchaOptions) (*Solution, error)
+	Kasada      func(KasadaOptions) (*KasadaSolution, error)
 }
 
 // GetBalance returns the balance of the account
@@ -49,6 +50,14 @@ func (s *Solver) FunCaptcha(o FunCaptchaOptions) (*Solution, error) {
 	return s.methods.FunCaptcha(o)
 }
 
+// Kasada is only supported with capsolver.com
+func (s *Solver) Kasada(o KasadaOptions) (*KasadaSolution, error) {
+	if s.methods.Kasada == nil {
+		return nil, errors.New("service does not support kasada")
+	}
+	return s.methods.Kasada(o)
+}
+
 // RecaptchaV3Options All fields are required
 type RecaptchaV3Options struct {
 	PageURL    string
@@ -79,6 +88,23 @@ type FunCaptchaOptions struct {
 	Data string
 }
 
+type KasadaOptions struct {
+	PageURL string
+	Proxy   *Proxy
+
+	// DetailedCD Enable if you need more detailed x-kpsdk-cd, including params such as duration, st and rst
+	DetailedCD bool
+
+	// OnlyCD Enable if the solution contains only x-kpsdk-cd
+	OnlyCD bool
+
+	// Version Currently supports 2.0 and 3.0, default is 3.0
+	Version string
+
+	// UserAgent Browser's User-Agent which is used in emulation. Default is random
+	UserAgent string
+}
+
 type HCaptchaOptions struct {
 	PageURL           string
 	SiteKey           string
@@ -122,6 +148,9 @@ type Solution struct {
 	Text   string
 	TaskId int
 
+	// RawSolution not supported on 2captcha methods
+	RawSolution map[string]interface{}
+
 	// Speed the time in milliseconds that the captcha took to solve
 	Speed int64
 
@@ -134,3 +163,16 @@ type Solution struct {
 	// IP can be "" if the service does not return IP
 	IP string
 }
+
+type KasadaSolution struct {
+	*Solution
+
+	// KpsdkCT is the 'x-kpsdk-ct' header
+	KpsdkCT string
+
+	// KpsdkCD is the 'x-kpsdk-cd' header
+	KpsdkCD string
+
+	// UserAgent is the user agent used to solve the captcha
+	UserAgent string
+}