Server

import hmac
import hashlib

def generate_sign_token(lot_number, captcha_key):
    """Generate verification signature"""
    sign_token = hmac.new(
        captcha_key.encode('utf-8'),
        lot_number.encode('utf-8'),
        digestmod=hashlib.sha256
    ).hexdigest()
    return sign_token

# Usage example
sign_token = generate_sign_token(lot_number, CAPTCHA_KEY)

const crypto = require('crypto');

function generateSignToken(lotNumber, captchaKey) {
    return crypto
        .createHmac('sha256', captchaKey)
        .update(lotNumber)
        .digest('hex');
}

// Usage example
const signToken = generateSignToken(lotNumber, CAPTCHA_KEY);

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public String generateSignToken(String lotNumber, String captchaKey)
    throws Exception {
    Mac mac = Mac.getInstance("HmacSHA256");
    SecretKeySpec secretKey = new SecretKeySpec(
        captchaKey.getBytes("UTF-8"),
        "HmacSHA256"
    );
    mac.init(secretKey);

    byte[] hash = mac.doFinal(lotNumber.getBytes("UTF-8"));
    return bytesToHex(hash);
}

private String bytesToHex(byte[] bytes) {
    StringBuilder result = new StringBuilder();
    for (byte b : bytes) {
        result.append(String.format("%02x", b));
    }
    return result.toString();
}

<?php
function generateSignToken($lotNumber, $captchaKey) {
    return hash_hmac('sha256', $lotNumber, $captchaKey);
}

// Usage example
$signToken = generateSignToken($lotNumber, $captchaKey);
?>

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
)

func GenerateSignToken(lotNumber, captchaKey string) string {
    h := hmac.New(sha256.New, []byte(captchaKey))
    h.Write([]byte(lotNumber))
    return hex.EncodeToString(h.Sum(nil))
}

// Usage example
signToken := GenerateSignToken(lotNumber, captchaKey)

import hmac
import hashlib
import requests

def validate_captcha(request_data):
    """Captcha secondary verification"""
    # Configuration parameters
    CAPTCHA_ID = 'YOUR_CAPTCHA_ID'
    CAPTCHA_KEY = 'YOUR_CAPTCHA_KEY'
    API_URL = 'https://cap-global.geelabapi.com/validate'

    # Get client parameters
    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')

    # Generate signature
    sign_token = hmac.new(
        CAPTCHA_KEY.encode(),
        lot_number.encode(),
        hashlib.sha256
    ).hexdigest()

    # Construct request parameters
    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
    }

    # Send request
    try:
        response = requests.post(API_URL, params=params, data=data, timeout=5)

        if response.status_code != 200:
            # API exception, recommend allowing
            return {'result': 'success', 'reason': 'api error, fallback'}

        result = response.json()
        return result

    except Exception as e:
        # Request exception, recommend allowing
        print(f'Verification exception: {e}')
        return {'result': 'success', 'reason': 'request fail, fallback'}

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

async function validateCaptcha(requestData) {
    // Configuration parameters
    const CAPTCHA_ID = 'YOUR_CAPTCHA_ID';
    const CAPTCHA_KEY = 'YOUR_CAPTCHA_KEY';
    const API_URL = 'https://cap-global.geelabapi.com/validate';

    // Get client parameters
    const { lot_number, captcha_output, pass_token, gen_time } = requestData;

    // Generate signature
    const sign_token = crypto
        .createHmac('sha256', CAPTCHA_KEY)
        .update(lot_number)
        .digest('hex');

    // Construct request parameters
    const params = new URLSearchParams({
        lot_number,
        captcha_output,
        pass_token,
        gen_time,
        sign_token
    });

    // Send request
    try {
        const response = await axios.post(
            `${API_URL}?captcha_id=${CAPTCHA_ID}`,
            params,
            {
                timeout: 5000,
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                }
            }
        );

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

        return response.data;

    } catch (error) {
        // Request exception, recommend allowing
        console.error('Verification exception:', error);
        return { result: 'success', reason: 'request fail, fallback' };
    }
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.http.*;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;

public class CaptchaValidator {
    private static final String CAPTCHA_ID = "YOUR_CAPTCHA_ID";
    private static final String CAPTCHA_KEY = "YOUR_CAPTCHA_KEY";
    private static final String API_URL = "https://cap-global.geelabapi.com/validate";

    public ValidationResult validate(CaptchaRequest request) {
        try {
            // Generate signature
            String signToken = generateSignToken(
                request.getLotNumber(),
                CAPTCHA_KEY
            );

            // Construct request parameters
            String params = String.format(
                "lot_number=%s&captcha_output=%s&pass_token=%s&gen_time=%s&sign_token=%s",
                request.getLotNumber(),
                request.getCaptchaOutput(),
                request.getPassToken(),
                request.getGenTime(),
                signToken
            );

            String url = API_URL + "?captcha_id=" + CAPTCHA_ID;

            // Send request
            HttpClient client = HttpClient.newHttpClient();
            HttpRequest httpRequest = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Content-Type", "application/x-www-form-urlencoded")
                .POST(HttpRequest.BodyPublishers.ofString(params))
                .timeout(Duration.ofSeconds(5))
                .build();

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

            // Handle response
            if (response.statusCode() != 200) {
                // API exception, recommend allowing
                return ValidationResult.fallback();
            }

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

        } catch (Exception e) {
            // Request exception, recommend allowing
            e.printStackTrace();
            return ValidationResult.fallback();
        }
    }

    private String generateSignToken(String lotNumber, String key)
        throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKey = new SecretKeySpec(
            key.getBytes("UTF-8"),
            "HmacSHA256"
        );
        mac.init(secretKey);

        byte[] hash = mac.doFinal(lotNumber.getBytes("UTF-8"));
        return bytesToHex(hash);
    }

    private String bytesToHex(byte[] bytes) {
        StringBuilder result = new StringBuilder();
        for (byte b : bytes) {
            result.append(String.format("%02x", b));
        }
        return result.toString();
    }
}

<?php
function validateCaptcha($requestData) {
    // Configuration parameters
    $CAPTCHA_ID = 'YOUR_CAPTCHA_ID';
    $CAPTCHA_KEY = 'YOUR_CAPTCHA_KEY';
    $API_URL = 'https://cap-global.geelabapi.com/validate';

    // Get client parameters
    $lot_number = $requestData['lot_number'];
    $captcha_output = $requestData['captcha_output'];
    $pass_token = $requestData['pass_token'];
    $gen_time = $requestData['gen_time'];

    // Generate signature
    $sign_token = hash_hmac('sha256', $lot_number, $CAPTCHA_KEY);

    // Construct request parameters
    $params = http_build_query([
        'lot_number' => $lot_number,
        'captcha_output' => $captcha_output,
        'pass_token' => $pass_token,
        'gen_time' => $gen_time,
        'sign_token' => $sign_token
    ]);

    $url = $API_URL . '?captcha_id=' . $CAPTCHA_ID;

    // Send request
    $context = stream_context_create([
        'http' => [
            'method' => 'POST',
            'header' => 'Content-Type: application/x-www-form-urlencoded',
            'content' => $params,
            'timeout' => 5
        ]
    ]);

    try {
        $response = @file_get_contents($url, false, $context);

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

        $result = json_decode($response, true);
        return $result;

    } catch (Exception $e) {
        // Exception handling, recommend allowing
        error_log('Verification exception: ' . $e->getMessage());
        return ['result' => 'success', 'reason' => 'exception, fallback'];
    }
}
?>

package main

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

const (
    CAPTCHA_ID  = "YOUR_CAPTCHA_ID"
    CAPTCHA_KEY = "YOUR_CAPTCHA_KEY"
    API_URL     = "https://cap-global.geelabapi.com/validate"
)

type ValidationResult struct {
    Status string                 `json:"status"`
    Result string                 `json:"result"`
    Reason string                 `json:"reason"`
    Args   map[string]interface{} `json:"captcha_args"`
}

func ValidateCaptcha(requestData map[string]string) (*ValidationResult, error) {
    // Get client parameters
    lotNumber := requestData["lot_number"]
    captchaOutput := requestData["captcha_output"]
    passToken := requestData["pass_token"]
    genTime := requestData["gen_time"]

    // Generate signature
    h := hmac.New(sha256.New, []byte(CAPTCHA_KEY))
    h.Write([]byte(lotNumber))
    signToken := hex.EncodeToString(h.Sum(nil))

    // Construct request parameters
    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)

    // Send request
    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 {
        // Request exception, recommend allowing
        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
}