So lösen Sie Capy Puzzle in Python, vom Schlüssel bis zum Formularversand

Um Capy Puzzle in Python zu lösen, lesen Sie den PUZZLE_-Schlüssel der Website von der Seite ab, rufen solver.capy() aus dem Paket capskip mit diesem Schlüssel und der Seiten-URL auf und senden dann die drei zurückgegebenen Werte in den Formularfeldern capy_captchakey, capy_challengekey und capy_answer ab, zusammen und sofort. Rufen Sie die Seite ab und senden Sie das Formular über dieselbe requests-Session, damit die Cookies der Website mit der Antwort zurückgehen. Überraschend ist für viele die Form des Ergebnisses. Die meisten Captcha-Typen liefern einen einzigen Token; Capy liefert drei Werte, die nur als Satz funktionieren, und einer davon läuft schnell ab. CapSkip hat Capy Puzzle in Version 1.4.0 hinzugefügt. Dieser Leitfaden behandelt den Schlüssel, den Aufruf, die zweisekündige Haltezeit, die absichtlich da ist, das Absenden, Wiederholungen und das gleichzeitige Ausführen vieler Lösevorgänge.

Was Sie brauchen

• CapSkip 1.4.0 oder neuer auf einem Windows-Rechner. Die Unterstützung für Capy kam mit diesem Release, zusammen mit CaptchaFox und Friendly Captcha.
• Python 3.10 oder neuer und Version 1.3.0 oder neuer des Pakets capskip, das erste Release mit einer Methode capy(). Die Beispiele verwenden außerdem requests, und der Abschnitt über parallele Lösevorgänge verwendet httpx.
• Zwei Werte von der Zielseite: der Capy-Schlüssel, der mit PUZZLE_ beginnt, und die URL der Seite, auf der das Widget läuft. Schritt 1 zeigt, wo Sie den Schlüssel finden, und an derselben Stelle sehen Sie auch, ob Sie einen dritten, optionalen Wert brauchen.
• Eine Adresse für den Solver. Im Local-Modus antwortet CapSkip auf 127.0.0.1 nur für dieses Gerät; im Server-Modus lauscht es auf Ihrer Netzwerkadresse oder öffentlichen IP, damit ein Skript auf einem anderen Rechner es über die API aufrufen kann. Eingestellt werden beide Modi unter Verbindungseinstellungen, und ein Abschnitt weiter unten erklärt, wann Sie wechseln sollten.

# Quoted, so cmd.exe does not read >= as a redirect
pip install "capskip>=1.3.0" requests httpx

Schritt 1: Den PUZZLE_-Schlüssel und den Capy-Host finden

Alles, was Sie brauchen, stammt von der Zielseite, und der Schlüssel ist öffentlich und für jeden Besucher identisch. Websites tragen ihn an zwei Stellen. Der Parameter k in der URL des Widget-Skripts steht im HTML, das requests herunterlädt. Sobald das Widget in einem Browser gelaufen ist, steht der Schlüssel außerdem in einem versteckten Eingabefeld capy_captchakey, das das Widget in das Formular schreibt, und dort zeigen ihn auch die DevTools an. Ein einziger regulärer Ausdruck für das Präfix PUZZLE_ findet ihn an beiden Stellen.

import re

import requests

PAGE_URL = "https://example.com/login"
session = requests.Session()
html = session.get(PAGE_URL, timeout=30).text

# The widget script's k= parameter. The capy_captchakey input only
# exists once the widget has run in a browser.
key = re.search(r"PUZZLE_[A-Za-z0-9_-]+", html)

# The widget script's own host; None means the default one.
host = re.search(r"(https://[^\"'\s<>]+?)/puzzle/get_js/", html)
api_server = host.group(1) if host else None
print(key and key.group(0), api_server)

Wenn Sie sich schon das Script-Tag ansehen, notieren Sie auch seinen Host. Alles in der Skript-URL vor /puzzle/get_js/ ist die Capy API, hinter der der Schlüssel liegt, und CapSkip nennt sie api_server. Standardwert ist https://jp.api.capy.me, wo der Live-Dienst läuft. Sie brauchen den Wert also nur, wenn eine Seite das Widget von woanders lädt. Eine Falle kommt aus der Dokumentation anderer Solver: Mehrere davon zeigen noch api.capy.me ohne das regionale Präfix, und dieser Host wird nicht mehr aufgelöst. Setzt ein altes Beispiel ihn, löschen Sie die Option.

Der Abruf läuft absichtlich über eine requests.Session. Das Formular, das Sie in Schritt 3 absenden, hängt oft von einem Session-Cookie ab, das die Seite gesetzt hat, und ein Session-Objekt sendet es ohne zusätzlichen Code zurück.

Schritt 2: Der Aufruf von capy()

Um Capy Puzzle in Python zu lösen, brauchen Sie eine einzige Methode. Sie nimmt den Schlüssel und die Seiten-URL sowie optionale Keyword-Argumente entgegen, und für eine Seite auf dem Standard-Host braucht sie nur diese beiden Werte.

# pip install "capskip>=1.3.0"
from capskip import CapSkip

solver = CapSkip(host="127.0.0.1", port=8080)

result = solver.capy("PUZZLE_YOUR_KEY", "https://example.com/login")

print(result["captchakey"])     # goes in capy_captchakey
print(result["challengekey"])   # goes in capy_challengekey
print(result["answer"])         # goes in capy_answer

Das Ergebnis ist ein einfaches dict. Lesen Sie die drei benannten Schlüssel aus. Unter dem Schlüssel code steht das gesamte Antwortobjekt des Servers, ein dict mit allen vier Feldern, das sich gut zum Loggen eignet, und respKey ist ein leerer String, der nur zur Kompatibilität mit anderen Diensten existiert. Die Antwort ist ein langer String, der ungefähr so beginnt: 0xax8ex0xax84x. Das ist der Ziehpfad, den das Widget beim Bewegen des Teils aufgezeichnet hätte, keine Koordinate.

Optionen, die die Methode annimmt

Die Methode capy() entfernt jedes Keyword-Argument mit dem Wert None, bevor die Anfrage hinausgeht. Sie können den Host aus Schritt 1 also bei jedem Aufruf übergeben und die Regex entscheiden lassen, ob er gesendet wird.

result = solver.capy(
    key.group(0),
    PAGE_URL,
    # None (no get_js script on the page) is dropped, and CapSkip
    # then uses its default host.
    api_server=api_server,
    # Poll every half second; see the next section for why.
    polling_interval=0.5,
)

Neben api_server nimmt capy() proxy, proxytype und useragent an, dazu timeout und polling_interval pro Aufruf, beide in Sekunden. Der User-Agent wird, falls Sie einen setzen, bei der einzigen Anfrage mitgesendet, die CapSkip zum Abrufen des Puzzles stellt, und Sie werden ihn selten brauchen. Es gibt auch eine Option version, aber nur puzzle wird akzeptiert. Die andere Familie von Capy, avatar, ist eine andere Challenge hinter einem anderen Endpunkt, daher lehnt das SDK sie mit einer ValidationException ab, statt eine Antwort zu liefern, die die Website zurückweisen würde. Ein unbekanntes Keyword, ein leerer Schlüssel, eine leere Seiten-URL oder ein anderer Proxy-Typ als HTTP, HTTPS, SOCKS5 oder SOCKS5H löst dieselbe Exception aus, bevor irgendetwas gesendet wird.

Warum ein Capy-Lösevorgang etwa zwei Sekunden dauert

Die Erkennung selbst ist schnell. CapSkip ruft das Puzzle-Bild ab, findet die Lücke mit etwas Pixel-Mathematik und baut den Ziehpfad, ganz ohne Browser und ohne Modell. Dann wartet es, und zwar absichtlich.

Capy misst die Zeit zwischen der Ausgabe eines Puzzles und dem Eintreffen der Antwort und lehnt alles ab, was schneller ankommt, als ein Mensch das Teil hätte ziehen können. Die eigenen Tests von CapSkip gegen Capy setzen diese Untergrenze bei etwa einer Sekunde an, und die Ablehnung trägt dieselbe Meldung wie eine falsche Antwort. Eine korrekte, aber zu schnell gelieferte Lösung sieht deshalb genau aus wie ein kaputter Solver. CapSkip hält daher jedes Capy-Ergebnis zurück, bis seit dem Abruf des Puzzles zwei Sekunden vergangen sind. Das Warten ist ein Sleep, es kostet also Latenz und keine CPU.

Warum ein Aufruf mit den Standardeinstellungen eher vier Sekunden dauert: Das SDK fragt ab, sobald es den Job an CapSkip gesendet hat, dann erneut nach einer Viertelsekunde, und verdoppelt den Abstand immer weiter bis zu seinem pollingInterval, standardmäßig 5 Sekunden. Die Abfragen fallen auf 0, 0.25, 0.75, 1.75 und 3.75 Sekunden, eine Antwort nach zwei Sekunden wird also bei der fünften Abfrage abgeholt. Mit polling_interval=0.5 beim Aufruf, oder pollingInterval=0.5 im Konstruktor, wenn der Client überwiegend Capy löst, kehrt der Aufruf gut zwei Sekunden nach dem Senden des Jobs zurück, in unseren Tests nach etwa 2.3 Sekunden. Bauen Sie keine eigene Verzögerung ein, bevor Sie das Formular absenden, und versuchen Sie nicht, die Haltezeit einzusparen: Genau sie sorgt dafür, dass die Antwort durchgeht.

Schritt 3: Alle drei Werte in einer Anfrage absenden

Die drei Werte gehören in die Felder, die das Widget selbst in das Formular geschrieben hätte. Senden Sie sie zusammen, in derselben Anfrage wie den Rest des Formulars, über die Session, die die Seite abgerufen hat.

# session is the one Step 1 used, so the page's cookies go back too.
resp = session.post(
    PAGE_URL,  # or wherever the form's action attribute points
    data={
        "username": "YOUR_USERNAME",
        "capy_captchakey": result["captchakey"],
        "capy_challengekey": result["challengekey"],
        "capy_answer": result["answer"],
    },
    timeout=30,
)
print(resp.status_code)

Senden Sie die Antwort genau so ab, wie sie zurückkam. Das Backend der Website prüft sie gegen das ausgegebene Puzzle, daher macht jedes Kürzen, jedes Neuzusammensetzen und jedes Aufräumen sie ungültig. Die Bibliothek requests kodiert den Formular-Body per Prozentkodierung, und das ist in Ordnung, denn der Server dekodiert ihn vor der Prüfung. Senden Sie dann zügig ab. CapSkip erzeugt für jeden Lösevorgang einen frischen Challenge-Key, und das Puzzle ist an ihn gebunden. Der Challenge-Key ist also nur einmal verwendbar und kurzlebig, und eine Lösung deckt ein Absenden ab.

Bilden Sie nach, was das echte Formular sendet. Die meisten Seiten tragen eigene versteckte Felder, etwa einen Anti-Forgery-Token, und manche senden per Skript mit einem JSON-Body statt als Formular-POST. Senden Sie einmal von Hand mit geöffneten DevTools ab, kopieren Sie die Anfrage und setzen Sie die drei Capy-Werte dort ein, wo die Seite sie einsetzt.

Schritt 4: Wiederholungen, wenn ein Lösevorgang scheitert

Wenn Sie Capy Puzzle in Python in nennenswertem Umfang lösen, werden einige Lösungsversuche scheitern. Ein gescheiterter Lösevorgang kommt als ApiException an, deren Meldung ERROR_CAPTCHA_UNSOLVABLE enthält, und über res.php, den Endpunkt, den das SDK abfragt, deckt dieser eine Code zwei verschiedene Situationen ab. Unterscheiden lassen sie sich daran, wie oft sie auftreten.

Fehltreffer sind selten, ein erneuter Versuch deckt also fast alles ab. Setzen Sie Retries im Capy-Bereich der CapSkip-Einstellungen (standardmäßig 0, erlaubt sind bis zu drei pro Aufgabe), oder wiederholen Sie in Ihrem eigenen Code:

from capskip import ApiException


def solve_capy(key, url, attempts=3, **options):
    for attempt in range(1, attempts + 1):
        try:
            return solver.capy(key, url, **options)
        except ApiException as exc:
            # A missed hole reads as unsolvable, and the next try
            # draws a new puzzle. Anything else is final.
            if "UNSOLVABLE" not in str(exc) or attempt == attempts:
                raise

Die Methode capy() pollt mit dem defaultTimeout des Clients, 120 Sekunden, denn ein Capy-Lösevorgang besteht aus einem Abruf und etwas Arithmetik und nicht aus einer Browser-Sitzung. CapSkip misst zusätzlich selbst die Zeit: Im Capy-Bereich kann eine Aufgabe bis zu 250 Sekunden (Wait Timeout) auf einen der 10 Threads (Max. Threads) warten, und ein Versuch bekommt 60 Sekunden (Row Timeout). Ein normaler Lösevorgang passt um ein Vielfaches in all das hinein.

Viele Capy-Puzzles gleichzeitig lösen

AsyncCapSkip ist in Python ein echter asyncio-Client und kein Alias, daher führt asyncio.gather mehrere Lösevorgänge parallel aus. Halten Sie jeden Lösevorgang mit seinem eigenen Absenden zusammen. Wer erst hundert Lösungen sammelt und danach absendet, lässt die frühesten Challenge-Keys altern, während die letzten Lösungen noch laufen.

import asyncio

import httpx
from capskip import AsyncCapSkip

solver = AsyncCapSkip(host="127.0.0.1", port=8080, pollingInterval=0.5)
slots = asyncio.Semaphore(10)  # CapSkip's Capy Max. Threads


async def solve_and_submit(key, url, form):
    # One client per job, so each form session keeps its own cookies.
    async with slots, httpx.AsyncClient(
            timeout=30, follow_redirects=True) as client:
        await client.get(url)
        result = await solver.capy(key, url)
        return await client.post(url, data={
            **form,
            "capy_captchakey": result["captchakey"],
            "capy_challengekey": result["challengekey"],
            "capy_answer": result["answer"],
        })


async def main(jobs):
    return await asyncio.gather(
        *(solve_and_submit(*job) for job in jobs), return_exceptions=True)

Der Semaphor entspricht der Thread-Zahl von CapSkip, sodass kein Job in der Warteschlange von CapSkip wartet und dabei eine Session offen hält, und er stammt aus der Python-Standardbibliothek, dokumentiert unter asyncio.Semaphore. Bei hohem Volumen fügen Sie außerdem Proxys hinzu. Jeder Lösevorgang holt ein neues Puzzle von der Capy API, und ein stetiger Strom solcher Abrufe von einer einzigen Adresse ist genau das Muster, für das es Rate Limiting gibt. Konfigurieren Sie einen Proxy-Pool im Capy-Bereich von CapSkip, oder übergeben Sie bei jedem Aufruf ein proxy-dict mit type und uri; der Proxy betrifft nur den Abruf des Puzzles, die einzige Anfrage, die ein Capy-Lösevorgang stellt. Weitere asyncio-Muster finden Sie im Leitfaden zum parallelen Lösen von Captchas in Python.

Den Löser auf einer anderen Maschine betreiben

127.0.0.1 ist richtig, solange das Skript und CapSkip auf demselben Windows-PC laufen. Sobald der Python-Code auf einen VPS, in einen Container, auf einen CI-Runner oder in ein gehostetes Notebook umzieht, zeigt Loopback auf den falschen Rechner, und der erste Lösevorgang löst eine NetworkException aus. Schalten Sie CapSkip in den Server-Modus, dann lauscht es auf Ihrer Netzwerkadresse oder öffentlichen IP, sodass jede dieser Umgebungen es über dieselbe API aufrufen kann. Verwenden Sie eine statische öffentliche IP, wenn der Weg über das Internet führt, aktivieren Sie die Validierung des API-Schlüssels und beschränken Sie den Port mit einer Regel in der Windows Firewall auf die Adressen, die Sie erwarten. Der Solver bleibt Ihr eigener Windows-Rechner, und abgerechnet wird pro Lösung weiterhin nichts.

Das SDK liest Umgebungsvariablen nicht von selbst. Lesen Sie CAPSKIP_HOST, CAPSKIP_PORT und CAPSKIP_API_KEY in Ihrem Code aus und übergeben Sie die Werte an den Konstruktor, wie es das vollständige Beispiel tut. So läuft dasselbe Skript an Ihrem Schreibtisch und auf einem Server.

Vollständiges lauffähiges Beispiel

# pip install "capskip>=1.3.0" requests
import os
import re

import requests
from capskip import (ApiException, CapSkip, CapSkipError,
                     TimeoutException, ValidationException)

PAGE_URL = "https://example.com/login"

solver = CapSkip(
    apiKey=os.getenv("CAPSKIP_API_KEY", "capskip"),
    host=os.getenv("CAPSKIP_HOST", "127.0.0.1"),
    port=int(os.getenv("CAPSKIP_PORT", "8080")),
    # Capy answers after a two second hold; poll often enough to catch it.
    pollingInterval=0.5,
)
session = requests.Session()

html = session.get(PAGE_URL, timeout=30).text
key = re.search(r"PUZZLE_[A-Za-z0-9_-]+", html)
if not key:
    raise SystemExit("No PUZZLE_ key in the HTML; find it in DevTools.")
host = re.search(r"(https://[^\"'\s<>]+?)/puzzle/get_js/", html)

try:
    for attempt in range(1, 4):
        try:
            result = solver.capy(key.group(0), PAGE_URL,
                                 api_server=host.group(1) if host else None)
            break
        except ApiException as exc:
            # A missed hole reads as unsolvable; the next try draws a new puzzle.
            if "UNSOLVABLE" not in str(exc) or attempt == 3:
                raise
            print(f"attempt {attempt}: {exc}")
except ValidationException as exc:
    raise SystemExit(f"not sent: {exc}")
except TimeoutException:
    raise SystemExit("gave up waiting; defaultTimeout is 120 seconds")
except CapSkipError as exc:
    # A third miss, a refused key, or CapSkip unreachable.
    raise SystemExit(f"solve failed: {exc!r}")

# All three together, straight away: the challenge key is single-use.
resp = session.post(
    PAGE_URL,  # or wherever the form's action attribute points
    data={
        "username": "YOUR_USERNAME",
        "capy_captchakey": result["captchakey"],
        "capy_challengekey": result["challengekey"],
        "capy_answer": result["answer"],
    },
    timeout=30,
)
print(resp.status_code)

Scheitern alle drei Versuche, sehen Sie sich zuerst den Schlüssel an, denn ein abgelehnter Schlüssel scheitert jedes Mal gleich, während ein Fehltreffer fast nie dreimal hintereinander passiert. Baut die Seite das Widget aus einem gebündelten Skript auf und findet die Regex nichts, öffnen Sie den Network-Tab und kopieren Sie Schlüssel und Host aus der eigenen Anfrage des Widgets. Den rohen Endpunkt hinter dieser Methode finden Sie im Capy-Abschnitt der API-Referenz.

Häufige Fehler und was sie bedeuten

FAQ

Die Kurzfassung

Um Capy Puzzle in Python zu lösen, rufen Sie die Seite mit einer requests-Session ab, ziehen den PUZZLE_-Schlüssel mit einer einzigen Regex heraus und notieren den Host des Widget-Skripts, falls es nicht der Standard ist. Rufen Sie solver.capy() mit dem Schlüssel und der echten Seiten-URL auf und lassen Sie ihm seine paar Sekunden, mit polling_interval=0.5 etwa 2.3. Senden Sie captchakey, challengekey und answer in den drei capy_-Feldern ab, unverändert, zusammen und sofort, über dieselbe Session. Wiederholen Sie den gelegentlichen Fehltreffer, fügen Sie Proxys hinzu, wenn das Volumen wächst, und wechseln Sie in den Server-Modus, sobald das Skript den Rechner des Solvers verlässt.

• Wie der Typ funktioniert und was der Solver abdeckt: die Capy-Puzzle-Solver-Seite.
• Alle Captcha-Typen, die das Python-Paket verarbeitet, finden Sie auf der Python-Captcha-Solver-Seite.

Noch ein letzter Punkt zu dieser Wiederholung. Jeder Versuch bekommt ein anderes Puzzle, daher ist ein neuer Anlauf die richtige Abhilfe bei einem Fehltreffer, und da ein unbegrenzter Captcha-Löser auf Ihrem eigenen Rechner läuft, kostet ein zweiter Versuch ein paar Sekunden statt einer weiteren abgerechneten Lösung.