Verificação no lado do servidor

Ao adicionar o código do lado do cliente, você conseguiu renderizar um widget Procaptcha que identificava se os usuários eram pessoas reais ou bots automatizados. Quando o captcha foi bem-sucedido, o script Procaptcha inseriu dados únicos nos dados do seu formulário, que são então enviados para o seu servidor para verificação. Existem atualmente duas opções para verificar a resposta do usuário no lado do servidor:

Verificação por API

Para verificar se o token é realmente real e válido, você deve agora verificá-lo no endpoint da API:

https://api.prosopo.io/siteverify

O endpoint espera uma solicitação POST com o token procaptcha-response. Você também deve passar sua secret key, que você pode obter fazendo login no nosso portal do cliente.

Um teste simples ficará assim, onde o conteúdo em data é o token procaptcha-response, após ser analisado:

// pseudocódigo
// obter o conteúdo do token procaptcha-response
data = req.body['procaptcha-response']

// enviar uma solicitação POST application/json para o endpoint da API
response = POST('https://api.prosopo.io/siteverify', {
    token: data.token,
    secret: 'your_secret_key',
})

Ou, como um comando CURL:

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"}''

Observe que o endpoint espera o Content-Type application/json. Você pode ver exatamente o que é enviado usando

curl -vv

no exemplo acima. A resposta será um objeto JSON com uma chave verified, que será true se o token for válido e false se não for.

{
    "verified": true,
}

Se você for um cliente do Nível Premium, também receberá uma pontuação de risco associada à solicitação. Quanto mais próxima a pontuação estiver de 1, maior a probabilidade de que a solicitação seja de um bot.

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

Endereço IP Opcional

Você também pode passar o endereço IP do usuário para o endpoint de verificação, o que permitirá que a Prosopo execute verificações adicionais na solicitação. Isso é opcional, mas recomendado para melhor precisão. Para fazer isso, inclua o campo ip nos seus dados POST:

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

Exemplos de Código de Verificação

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; // Retornar campo verified, padrão 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; // Retornar campo verified, padrão 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)  # Retornar campo verified, padrão 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());
        }

        // Analisar resposta JSON
        JSONObject jsonResponse = new JSONObject(response.toString());
        return jsonResponse.optBoolean("verified", false); // Padrão false se não encontrado
    }
}

Pacote de Verificação

Temos uma implementação JavaScript do pacote de verificação Procaptcha disponível no npm.

Verificação JavaScript / TypeScript

O pacote @prosopo/server está disponível no NPM e pode ser instalado usando:

npm install @prosopo/server

Para verificar a resposta de um usuário usando JavaScript / TypeScript, simplesmente importe a função verify de @prosopo/server e passe a ela os dados POST procaptcha-response. Os tipos podem ser importados de @prosopo/types.

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

...
// analisar o corpo recebido do frontend
const payload = JSON.parse(event.body)

// analisar o token de resposta procaptcha
const procaptchaResponse = payload[ApiParams.procaptchaResponse]

// inicializar a classe `ProsopoServer`
const prosopoServer = new ProsopoServer(config)

// verificar se a resposta do captcha está verificada
if (await prosopoServer.isVerified(procaptchaResponse)) {
    // executar ação protegida por CAPTCHA
}

Há um exemplo de servidor TypeScript Exemplo de Servidor NodeJS no Lado do Servidor que você pode executar localmente.

Criar uma Issue no GitHub

Enviar feedback