服务端集成

import hmac
import hashlib
import requests

def validate_captcha(request_data):
    # 1. 获取参数
    lot_number = request_data.get('lot_number')
    captcha_output = request_data.get('captcha_output')
    pass_token = request_data.get('pass_token')
    gen_time = request_data.get('gen_time')

    # 2. 生成签名
    sign_token = hmac.new(
        CAPTCHA_KEY.encode(),
        lot_number.encode(),
        hashlib.sha256
    ).hexdigest()

    # 3. 调用验证接口
    try:
        response = requests.post(
            'https://cap-global.geelabapi.com/validate',
            params={'captcha_id': CAPTCHA_ID},
            data={
                'lot_number': lot_number,
                'captcha_output': captcha_output,
                'pass_token': pass_token,
                'gen_time': gen_time,
                'sign_token': sign_token
            },
            timeout=5
        )

        if response.status_code != 200:
            return {'result': 'success', 'reason': 'api error, fallback'}

        return response.json()

    except Exception as e:
        return {'result': 'success', 'reason': 'request fail, fallback'}

const crypto = require('crypto');
const axios = require('axios');

async function validateCaptcha(requestData) {
    // 1. 获取参数
    const { lot_number, captcha_output, pass_token, gen_time } = requestData;

    // 2. 生成签名
    const sign_token = crypto
        .createHmac('sha256', CAPTCHA_KEY)
        .update(lot_number)
        .digest('hex');

    // 3. 调用验证接口
    try {
        const response = await axios.post(
            `https://cap-global.geelabapi.com/validate?captcha_id=${CAPTCHA_ID}`,
            new URLSearchParams({
                lot_number,
                captcha_output,
                pass_token,
                gen_time,
                sign_token
            }),
            { timeout: 5000 }
        );

        if (response.status !== 200) {
            return { result: 'success', reason: 'api error, fallback' };
        }

        return response.data;

    } catch (error) {
        return { result: 'success', reason: 'request fail, fallback' };
    }
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.http.*;

public ValidationResult validate(CaptchaRequest request) {
    try {
        // 1. 生成签名
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKey = new SecretKeySpec(
            CAPTCHA_KEY.getBytes("UTF-8"),
            "HmacSHA256"
        );
        mac.init(secretKey);
        String signToken = bytesToHex(
            mac.doFinal(request.getLotNumber().getBytes("UTF-8"))
        );

        // 2. 调用验证接口
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest httpRequest = HttpRequest.newBuilder()
            .uri(URI.create(API_URL + "?captcha_id=" + CAPTCHA_ID))
            .POST(HttpRequest.BodyPublishers.ofString(params))
            .timeout(Duration.ofSeconds(5))
            .build();

        HttpResponse<String> response = client.send(
            httpRequest,
            HttpResponse.BodyHandlers.ofString()
        );

        if (response.statusCode() != 200) {
            return ValidationResult.fallback();
        }

        return mapper.readValue(response.body(), ValidationResult.class);

    } catch (Exception e) {
        return ValidationResult.fallback();
    }
}

<?php
function validateCaptcha($requestData) {
    // 1. 获取参数
    $lot_number = $requestData['lot_number'];
    $captcha_output = $requestData['captcha_output'];
    $pass_token = $requestData['pass_token'];
    $gen_time = $requestData['gen_time'];

    // 2. 生成签名
    $sign_token = hash_hmac('sha256', $lot_number, $CAPTCHA_KEY);

    // 3. 调用验证接口
    $url = 'https://cap-global.geelabapi.com/validate?captcha_id=' . $CAPTCHA_ID;
    $params = http_build_query([
        'lot_number' => $lot_number,
        'captcha_output' => $captcha_output,
        'pass_token' => $pass_token,
        'gen_time' => $gen_time,
        'sign_token' => $sign_token
    ]);

    try {
        $response = @file_get_contents($url, false, stream_context_create([
            'http' => [
                'method' => 'POST',
                'header' => 'Content-Type: application/x-www-form-urlencoded',
                'content' => $params,
                'timeout' => 5
            ]
        ]));

        if ($response === false) {
            return ['result' => 'success', 'reason' => 'request fail, fallback'];
        }

        return json_decode($response, true);

    } catch (Exception $e) {
        return ['result' => 'success', 'reason' => 'exception, fallback'];
    }
}
?>

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "net/http"
    "net/url"
    "strings"
    "time"
)

func ValidateCaptcha(requestData map[string]string) (*ValidationResult, error) {
    // 1. 获取参数
    lotNumber := requestData["lot_number"]
    captchaOutput := requestData["captcha_output"]
    passToken := requestData["pass_token"]
    genTime := requestData["gen_time"]

    // 2. 生成签名
    h := hmac.New(sha256.New, []byte(CAPTCHA_KEY))
    h.Write([]byte(lotNumber))
    signToken := hex.EncodeToString(h.Sum(nil))

    // 3. 调用验证接口
    data := url.Values{}
    data.Set("lot_number", lotNumber)
    data.Set("captcha_output", captchaOutput)
    data.Set("pass_token", passToken)
    data.Set("gen_time", genTime)
    data.Set("sign_token", signToken)

    client := &http.Client{Timeout: 5 * time.Second}
    apiURL := API_URL + "?captcha_id=" + CAPTCHA_ID

    resp, err := client.Post(
        apiURL,
        "application/x-www-form-urlencoded",
        strings.NewReader(data.Encode()),
    )

    if err != nil || resp.StatusCode != 200 {
        return &ValidationResult{
            Result: "success",
            Reason: "request fail, fallback",
        }, nil
    }

    defer resp.Body.Close()

    var result ValidationResult
    json.NewDecoder(resp.Body).Decode(&result)
    return &result, nil
}