CaptchaShield

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Http;

class ContactController extends Controller
{
    public function submit(Request $request)
    {
        // Validate form fields
        $validated = $request->validate([
            'email' => 'required|email',
            'message' => 'required|string',
            'captchaToken' => 'required|string',
        ]);

        // Verify CAPTCHA
        $response = Http::asForm()->post('https://captchashield.com/v1/siteverify', [
            'secret' => config('services.captchashield.secret'),
            'response' => $validated['captchaToken'],
            'remoteip' => $request->ip(),
        ]);

        $result = $response->json();

        if (!$result['success']) {
            return back()->withErrors([
                'captcha' => 'CAPTCHA verification failed. Please try again.'
            ]);
        }

        // Process form (save to DB, send email, etc.)
        // ...

        return redirect()->route('contact.success')
            ->with('message', 'Your message has been sent!');
    }
}
?>

'captchashield' => [
    'sitekey' => env('CAPTCHASHIELD_SITE_KEY'),
    'secret' => env('CAPTCHASHIELD_SECRET_KEY'),
],

const express = require('express');
const axios = require('axios');
const app = express();

app.use(express.json());
app.use(express.urlencoded({ extended: true }));

async function verifyCaptcha(token, remoteIp) {
    try {
        const response = await axios.post(
            'https://captchashield.com/v1/siteverify',
            new URLSearchParams({
                secret: process.env.CAPTCHASHIELD_SECRET_KEY,
                response: token,
                remoteip: remoteIp
            })
        );

        return response.data;
    } catch (error) {
        console.error('CAPTCHA verification error:', error);
        return { success: false, error_codes: ['network-error'] };
    }
}

app.post('/submit', async (req, res) => {
    const { email, message, captchaToken } = req.body;

    // Verify CAPTCHA
    const result = await verifyCaptcha(
        captchaToken,
        req.ip || req.connection.remoteAddress
    );

    if (!result.success) {
        return res.status(400).json({
            error: 'CAPTCHA verification failed',
            details: result.error_codes
        });
    }

    // Process form
    // ...

    res.json({ success: true, message: 'Form submitted successfully' });
});

app.listen(3000, () => console.log('Server running on port 3000'));

require 'net/http'
require 'json'

class ContactsController < ApplicationController
  def create
    captcha_token = params[:captchaToken]

    if verify_captcha(captcha_token, request.remote_ip)
      # Process form
      flash[:success] = 'Form submitted successfully!'
      redirect_to root_path
    else
      flash[:error] = 'CAPTCHA verification failed'
      render :new
    end
  end

  private

  def verify_captcha(token, remote_ip)
    uri = URI('https://captchashield.com/v1/siteverify')

    params = {
      secret: ENV['CAPTCHASHIELD_SECRET_KEY'],
      response: token,
      remoteip: remote_ip
    }

    response = Net::HTTP.post_form(uri, params)
    result = JSON.parse(response.body)

    result['success'] == true
  rescue => e
    Rails.logger.error "CAPTCHA verification error: #{e.message}"
    false
  end
end

from flask import Flask, request, jsonify
import requests
import os

app = Flask(__name__)

def verify_captcha(token, remote_ip):
    """Verify CAPTCHA token with CaptchaShield"""
    url = 'https://captchashield.com/v1/siteverify'

    payload = {
        'secret': os.environ.get('CAPTCHASHIELD_SECRET_KEY'),
        'response': token,
        'remoteip': remote_ip
    }

    try:
        response = requests.post(url, data=payload, timeout=5)
        result = response.json()
        return result.get('success', False)
    except Exception as e:
        print(f'CAPTCHA verification error: {e}')
        return False

@app.route('/submit', methods=['POST'])
def submit_form():
    data = request.get_json() or request.form
    captcha_token = data.get('captchaToken')

    if not captcha_token:
        return jsonify({'error': 'CAPTCHA token missing'}), 400

    # Verify CAPTCHA
    if not verify_captcha(captcha_token, request.remote_addr):
        return jsonify({'error': 'CAPTCHA verification failed'}), 400

    # Process form
    # ...

    return jsonify({'success': True, 'message': 'Form submitted'})

if __name__ == '__main__':
    app.run(debug=True)

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
    "os"
)

type CaptchaResponse struct {
    Success     bool     `json:"success"`
    ChallengeTS string   `json:"challenge_ts"`
    Hostname    string   `json:"hostname"`
    ErrorCodes  []string `json:"error_codes"`
}

func verifyCaptcha(token, remoteIP string) (bool, error) {
    secretKey := os.Getenv("CAPTCHASHIELD_SECRET_KEY")

    resp, err := http.PostForm("https://captchashield.com/v1/siteverify",
        url.Values{
            "secret":   {secretKey},
            "response": {token},
            "remoteip": {remoteIP},
        })

    if err != nil {
        return false, err
    }
    defer resp.Body.Close()

    var result CaptchaResponse
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return false, err
    }

    return result.Success, nil
}

func submitHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    captchaToken := r.FormValue("captchaToken")
    remoteIP := r.RemoteAddr

    success, err := verifyCaptcha(captchaToken, remoteIP)
    if err != nil || !success {
        http.Error(w, "CAPTCHA verification failed", http.StatusBadRequest)
        return
    }

    // Process form
    fmt.Fprintf(w, "Form submitted successfully")
}

func main() {
    http.HandleFunc("/submit", submitHandler)
    http.ListenAndServe(":8080", nil)
}

package com.example.demo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;
import java.util.Map;

@Service
class CaptchaService {

    @Value("${captchashield.secret}")
    private String secretKey;

    private final RestTemplate restTemplate = new RestTemplate();

    public boolean verify(String token, String remoteIp) {
        String url = "https://captchashield.com/v1/siteverify";

        MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
        params.add("secret", secretKey);
        params.add("response", token);
        params.add("remoteip", remoteIp);

        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

        HttpEntity<MultiValueMap<String, String>> request =
            new HttpEntity<>(params, headers);

        try {
            ResponseEntity<Map> response = restTemplate.postForEntity(
                url, request, Map.class);
            Map<String, Object> body = response.getBody();
            return body != null &&
                   Boolean.TRUE.equals(body.get("success"));
        } catch (Exception e) {
            return false;
        }
    }
}

@RestController
class ContactController {

    private final CaptchaService captchaService;

    public ContactController(CaptchaService captchaService) {
        this.captchaService = captchaService;
    }

    @PostMapping("/submit")
    public ResponseEntity<String> submit(
        @RequestParam String captchaToken,
        @RequestHeader("X-Forwarded-For") String remoteIp) {

        if (!captchaService.verify(captchaToken, remoteIp)) {
            return ResponseEntity
                .badRequest()
                .body("CAPTCHA verification failed");
        }

        // Process form
        return ResponseEntity.ok("Form submitted successfully");
    }
}

using Microsoft.AspNetCore.Mvc;
using System.Text.Json;

public class CaptchaService
{
    private readonly IConfiguration _configuration;
    private readonly IHttpClientFactory _httpClientFactory;

    public CaptchaService(
        IConfiguration configuration,
        IHttpClientFactory httpClientFactory)
    {
        _configuration = configuration;
        _httpClientFactory = httpClientFactory;
    }

    public async Task<bool> VerifyAsync(string token, string remoteIp)
    {
        var client = _httpClientFactory.CreateClient();
        var secretKey = _configuration["CaptchaShield:SecretKey"];

        var parameters = new Dictionary<string, string>
        {
            { "secret", secretKey },
            { "response", token },
            { "remoteip", remoteIp }
        };

        var content = new FormUrlEncodedContent(parameters);

        try
        {
            var response = await client.PostAsync(
                "https://captchashield.com/v1/siteverify",
                content);

            var json = await response.Content.ReadAsStringAsync();
            var result = JsonSerializer.Deserialize<CaptchaResponse>(json);

            return result?.Success ?? false;
        }
        catch
        {
            return false;
        }
    }
}

public class CaptchaResponse
{
    public bool Success { get; set; }
    public string? ChallengeTs { get; set; }
    public string? Hostname { get; set; }
    public string[]? ErrorCodes { get; set; }
}

[ApiController]
[Route("[controller]")]
public class ContactController : ControllerBase
{
    private readonly CaptchaService _captchaService;

    public ContactController(CaptchaService captchaService)
    {
        _captchaService = captchaService;
    }

    [HttpPost("submit")]
    public async Task<IActionResult> Submit([FromForm] string captchaToken)
    {
        var remoteIp = HttpContext.Connection.RemoteIpAddress?.ToString();

        if (!await _captchaService.VerifyAsync(captchaToken, remoteIp))
        {
            return BadRequest("CAPTCHA verification failed");
        }

        // Process form
        return Ok("Form submitted successfully");
    }
}

<?php
/**
 * Plugin Name: CaptchaShield Integration
 * Description: Adds CaptchaShield protection to forms
 */

function captchashield_verify_token($token) {
    $secret_key = get_option('captchashield_secret_key');

    $response = wp_remote_post('https://captchashield.com/v1/siteverify', [
        'body' => [
            'secret' => $secret_key,
            'response' => $token,
            'remoteip' => $_SERVER['REMOTE_ADDR']
        ]
    ]);

    if (is_wp_error($response)) {
        return false;
    }

    $body = json_decode(wp_remote_retrieve_body($response), true);

    return !empty($body['success']);
}

// Add widget to comment form
function captchashield_comment_form() {
    $site_key = get_option('captchashield_site_key');
    echo '<div class="captchashield" data-sitekey="' . esc_attr($site_key) . '" data-api="https://captchashield.com"></div>';
}
add_action('comment_form_after_fields', 'captchashield_comment_form');

// Add widget script to footer
function captchashield_enqueue_script() {
    wp_enqueue_script(
        'captchashield',
        'https://captchashield.com/widget.js',
        [],
        null,
        true
    );
}
add_action('wp_enqueue_scripts', 'captchashield_enqueue_script');

// Verify on comment submission
function captchashield_verify_comment($commentdata) {
    if (is_user_logged_in()) {
        return $commentdata; // Skip for logged-in users
    }

    $token = $_POST['captchaToken'] ?? '';

    if (!captchashield_verify_token($token)) {
        wp_die('CAPTCHA verification failed. Please go back and try again.');
    }

    return $commentdata;
}
add_filter('preprocess_comment', 'captchashield_verify_comment');
?>