Envoyer un jeton CAPTCHA via un proxy HTTP en Go

1. 1.

   Configurer le SDK Go et les identifiants

   Utilisez le module officiel solvethree.com/sdk, en version v0.1.0, avec Go 1.22 ou une version ultérieure. La référence d’intégration Go détaille la configuration. Définissez SOLVETHREE_API_KEY avec la clé API de votre espace de travail et conservez-la sur le serveur. Définissez SOLVETHREE_PROXY avec l’URL de votre proxy HTTP ou HTTPS.

2. 2.

   Configurer le site avant la résolution

   L’espace de travail doit disposer d’un profil actif pour le nom d’hôte cible. Configurez d’abord le profil de site ; l’envoi d’un nom d’hôte et d’une action n’en crée pas.

3. 3.

   Remplacer la cible de l’exemple

   Modifiez accounts.example.com, l’action login et le point de terminaison de l’application pour les adapter à votre intégration. Site est un nom d’hôte, pas une URL complète. Pour reCAPTCHA, fournissez exactement un seul des champs Proxy ou ProxyCandidates ; ne renseignez pas les champs Type ou URL de la tâche. Le type reCAPTCHA par défaut est Enterprise v3.

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "net/http"
    "net/url"
    "strings"
    "time"
    solvethree "solvethree.com/sdk"
)

func main() {
    client, err := solvethree.NewClient(os.Getenv("SOLVETHREE_API_KEY"), nil)
    if err != nil { log.Fatal(err) }
    ctx, cancel := context.WithTimeout(context.Background(), 180*time.Second)
    defer cancel()
    input := solvethree.TaskRequest{Site: "accounts.example.com", Action: "login", Proxy: os.Getenv("SOLVETHREE_PROXY")}
    result, err := client.Solve(ctx, input, solvethree.SolveOptions{})
    if err != nil { log.Fatal(err) }
    fmt.Println("Ready task:", result.ID)

    proxy, ok := solvethree.SuccessfulProxy(input, result)
    if !ok { log.Fatal("No valid successful proxy") }
    proxyURL, err := url.Parse(proxy)
    if err != nil { log.Fatal(err) }
    transport := http.DefaultTransport.(*http.Transport).Clone()
    transport.Proxy = http.ProxyURL(proxyURL)
    defer transport.CloseIdleConnections()
    targetClient := &http.Client{Transport: transport, Timeout: 30*time.Second,
        CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
    request, err := http.NewRequestWithContext(ctx, "POST", "https://accounts.example.com/login",
        strings.NewReader(url.Values{"g-recaptcha-response": {result.Solution.Token}}.Encode()))
    if err != nil { log.Fatal(err) }

    request.Header.Set("User-Agent", result.Solution.UserAgent)
    request.Header.Set("sec-ch-ua", result.Solution.SecChUA)
    request.Header.Set("Content-Type", "application/x-www-form-urlencoded")

    response, err := targetClient.Do(request)
    if err != nil { log.Fatal(err) }
    defer response.Body.Close()
    fmt.Println("Application HTTP status:", response.StatusCode)
    // Inspect the application response to determine whether submission succeeded.

}

Le SDK résout la tâche, mais ne soumet rien au site web. Après la résolution, l’exemple clone http.DefaultTransport et définit le Proxy du clone via http.ProxyURL. Seul le client distinct targetClient utilise ce transport ; le transport API du client SDK reste inchangé.

Conservez les identifiants du proxy dans la composante user-info de l’URL. url.Parse les préserve pour le transport via le proxy. Encodez en pourcentage les caractères réservés du nom d’utilisateur ou du mot de passe au lieu de découper manuellement l’URL ou d’envoyer les identifiants du proxy dans un en-tête Authorization destiné à la cible.

Conservez les données d’origine de la tâche et utilisez SuccessfulProxy même si vous ne fournissez actuellement qu’un seul proxy. Avec ProxyCandidates, le candidat qui a réussi est identifié par Solution.EgressAttempts, un indice commençant à un dans la liste d’origine. Cette fonction utilitaire évite de deviner quel candidat a fonctionné ; arrêtez-vous si elle renvoie false. Les listes de candidats acceptent au maximum douze URL distinctes de proxy HTTP ou HTTPS, sans chemin, paramètres de requête ni fragment.

L’exemple utilise url.Values pour encoder Solution.Token au format formulaire sous g-recaptcha-response et définit le type de contenu correspondant. Remplacez ce nom de champ si votre application en attend un autre. Ajoutez les autres champs requis par le point de terminaison, tels que les données de connexion et toute valeur anti-CSRF liée à la session ; un jeton CAPTCHA ne constitue pas une requête de connexion complète.

Utilisez les valeurs UserAgent et SecChUA renvoyées, comme dans l’exemple. Si la solution fournit aussi des entrées dans Headers, appliquez également ces en-têtes à la requête destinée à la cible — l’exemple ne copie pas cette collection. Conservez une identité de navigateur cohérente et un type de contenu adapté au corps envoyé.

L’exemple ne dispose pas de gestionnaire de cookies. Si la cible exige une session, créez-en un avec net/http/cookiejar, associez-le à targetClient.Jar avant de démarrer le parcours sur la cible, puis réutilisez ce client pour la requête de page et l’envoi du formulaire. Utilisez le même proxy ayant réussi tout au long de cette session. Le client API solvethree n’est pas le client de session de la cible.

Vérifiez l’erreur de résolution avant d’accéder à la solution. Seule une tâche prête contient une solution utilisable ; les champs errorCode et error d’une tâche échouée expliquent cet échec. Pour la requête vers la cible, gérez l’erreur renvoyée par Do, puis vérifiez le statut HTTP avant d’interpréter le corps de la réponse. Fermez response.Body chaque fois que Do renvoie une réponse sans erreur, y compris pour les réponses HTTP qui n’indiquent pas un succès.

L’exemple désactive les redirections automatiques et affiche le statut de l’application. Examinez le corps de la réponse et toute redirection attendue pour déterminer si l’application a accepté l’envoi. Une tâche prête, ou un statut HTTP de succès à lui seul, ne permet pas de le confirmer.