Serverseitige Verifizierung

Durch Hinzufügen des clientseitigen Codes konnten Sie ein Procaptcha Widget rendern, das identifiziert, ob Benutzer echte Personen oder automatisierte Bots sind. Wenn das CAPTCHA erfolgreich war, hat das Procaptcha-Skript eindeutige Daten in Ihre Formulardaten eingefügt, die dann zur Verifizierung an Ihren Server gesendet werden. Es gibt derzeit zwei Optionen zur serverseitigen Verifizierung der Benutzerantwort:

API-Verifizierung

Um zu verifizieren, dass das Token tatsächlich echt und gültig ist, müssen Sie es nun am API-Endpunkt verifizieren:

https://api.prosopo.io/siteverify

EU- und US-spezifische Endpunkte sind ebenfalls verfügbar, wenn Sie möchten, dass Ihre Daten in einer bestimmten Region verarbeitet werden:

Der Endpunkt erwartet eine POST-Anfrage mit dem procaptcha-response-Token. Sie müssen auch Ihren secret key übergeben, den Sie durch Anmeldung in unserem Kundenportal erhalten können.

Ein einfacher Test sieht folgendermaßen aus, wobei der Inhalt in data das procaptcha-response-Token nach dem Parsen ist:

// pseudocode
// get the contents of the procaptcha-response token
data = req.body['procaptcha-response']

// send a POST application/json request to the API endpoint
response = POST('https://api.prosopo.io/siteverify', {
    token: data.token,
    secret: 'your_secret_key',
})

Oder als CURL-Befehl:

curl --location 'https://api.prosopo.io/siteverify' \
--header 'Content-Type: application/json' \
--data '{"secret":"your secret key copied from within the customer portal","token":"PROCAPTCHA-RESPONSE"}''

Beachten Sie, dass der Endpunkt den Content-Type application/json erwartet. Sie können genau sehen, was gesendet wird, indem Sie

curl -vv

im obigen Beispiel verwenden. Die Antwort wird ein JSON-Objekt mit einem verified-Schlüssel sein, der true ist, wenn das Token gültig ist, und false, wenn es ungültig ist.

{
    "verified": true,
}

Wenn Sie ein Premium-Tier-Kunde sind, erhalten Sie auch einen Risiko-Score, der mit der Anfrage verbunden ist. Je näher der Score bei 1 liegt, desto wahrscheinlicher ist es, dass die Anfrage von einem Bot stammt.

{
    "verified": true,
    "score": 0.1
}

Optionale IP-Adresse

Sie können auch die IP-Adresse des Benutzers an den Verifizierungsendpunkt übergeben, was Prosopo erlaubt, zusätzliche Prüfungen an der Anfrage durchzuführen. Dies ist optional, aber für bessere Genauigkeit empfohlen. Um dies zu tun, fügen Sie das ip-Feld in Ihre POST-Daten ein:

{
    "secret": "your_secret_key",
    "token": "PROCAPTCHA-RESPONSE",
    "ip": "USER_IP_ADDRESS"
}

Verifizierungs-Codebeispiele

JavaScript

const fetch = require('node-fetch');

async function verifyToken(token) {
    const response = await fetch('https://api.prosopo.io/siteverify', {
        method: 'POST',
        headers: {'Content-Type': 'application/json'},
        body: JSON.stringify({ secret: 'your_secret_key', token }),
    });
    return response.json().verified || false; // Return verified field, default to false
}

PHP

<?php
function verifyToken($token) {
    $url = 'https://api.prosopo.io/siteverify';
    $data = json_encode(["secret" => "your_secret_key", "token" => $token]);
    $options = [
        'http' => [
            'header'  => "Content-Type: application/json\r\n",
            'method'  => 'POST',
            'content' => $data,
        ],
    ];
    $context  = stream_context_create($options);
    $result = file_get_contents($url, false, $context);
    $response = json_decode($result, true);

    return $response["verified"] ?? false; // Return verified field, default to false
}
?>

Python

import requests

def verify_token(token):
    url = "https://api.prosopo.io/siteverify"
    data = { "secret": "your_secret_key", "token": token }
    response = requests.post(url, json=data)
    return response.json().get("verified", False)  # Return verified field, default to False

Java

import java.io.*;
import java.net.*;
import org.json.JSONObject;

public class ProcaptchaVerification {
    public static boolean verifyToken(String token) throws Exception {
        URL url = new URL("https://api.prosopo.io/siteverify");
        HttpURLConnection con = (HttpURLConnection) url.openConnection();
        con.setRequestMethod("POST");
        con.setRequestProperty("Content-Type", "application/json");
        con.setDoOutput(true);

        String jsonInputString = "{\"secret\":\"your_secret_key\", \"token\":\"" + token + "\"}";
        try (OutputStream os = con.getOutputStream()) {
            byte[] input = jsonInputString.getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream(), "utf-8"));
        StringBuilder response = new StringBuilder();
        String responseLine;
        while ((responseLine = br.readLine()) != null) {
            response.append(responseLine.trim());
        }

        // Parse JSON response
        JSONObject jsonResponse = new JSONObject(response.toString());
        return jsonResponse.optBoolean("verified", false); // Default to false if not found
    }
}

Verifizierungspaket

Wir haben eine JavaScript-Implementierung des Procaptcha-Verifizierungspakets verfügbar auf npm.

JavaScript / TypeScript Verifizierung

Das @prosopo/server-Paket ist auf NPM verfügbar und kann installiert werden mit:

npm install @prosopo/server

Um eine Benutzerantwort mit JavaScript / TypeScript zu verifizieren, importieren Sie einfach die verify-Funktion aus @prosopo/server und übergeben Sie ihr die procaptcha-response POST-Daten. Typen können aus @prosopo/types importiert werden.

import {ProsopoServer} from '@prosopo/server'
import {ApiParams} from '@prosopo/types'

...
// parse the body received from the frontend
const payload = JSON.parse(event.body)

// parse the procaptcha response token
const procaptchaResponse = payload[ApiParams.procaptchaResponse]

// initialise the `ProsopoServer` class
const prosopoServer = new ProsopoServer(config)

// check if the captcha response is verified
if (await prosopoServer.isVerified(procaptchaResponse)) {
    // perform CAPTCHA protected action
}

Es gibt einen Beispiel-TypeScript-Server NodeJS Serverseitiges Beispiel, den Sie lokal ausführen können.

GitHub-Issue erstellen

Senden Sie uns Feedback