C#中Post请求时检测Captcha并触发人工验证的实现咨询

Hey there! Let's break down how to handle this CAPTCHA detection and manual verification flow in C# step by step—perfect for your repeated POST request scenario.

Step 1: Detect if CAPTCHA is Required #

First, you need to check if the target site is asking for reCAPTCHA by parsing the HTML response from your initial request. The data-site-key attribute on reCAPTCHA elements is the key indicator here. We'll use the HtmlAgilityPack library to make HTML parsing straightforward.

1. Install the package via NuGet:

   Install-Package HtmlAgilityPack
   

2. Code to check for CAPTCHA presence:

   using HtmlAgilityPack;
   using System.Net.Http;
   
   public async Task<bool> IsCaptchaRequiredAsync(HttpClient client, string targetUrl)
   {
       // Send your initial GET/POST request to fetch the page content
       var response = await client.GetAsync(targetUrl);
       var htmlContent = await response.Content.ReadAsStringAsync();
   
       var htmlDoc = new HtmlDocument();
       htmlDoc.LoadHtml(htmlContent);
   
       // Look for the reCAPTCHA div with the data-site-key attribute
       var captchaElement = htmlDoc.DocumentNode.SelectSingleNode("//div[@data-site-key]");
       return captchaElement != null;
   }
   

Step 2: Build a Manual Verification Window #

If CAPTCHA is detected, you'll need a way for a human to complete it. We'll create a WinForms window with a WebBrowser control to render the reCAPTCHA widget and capture the g-recaptcha-response token once verified.

1. Create a new WinForms Form (name it CaptchaVerificationForm):

   • Add a WebBrowser control (name it webBrowser1)
   • Add a status label to guide the user (optional but helpful)

2. Load the reCAPTCHA widget and listen for verification completion:

   public partial class CaptchaVerificationForm : Form
   {
       public string CaptchaResponse { get; private set; }
       private readonly string _siteKey;
   
       public CaptchaVerificationForm(string siteKey)
       {
           InitializeComponent();
           _siteKey = siteKey;
           LoadCaptchaWidget();
       }
   
       private void LoadCaptchaWidget()
       {
           // Inject HTML that loads the reCAPTCHA script and listens for completion
           var captchaHtml = $@"
           <html>
               <head>
                   <script src='https://www.google.com/recaptcha/api.js'></script>
               </head>
               <body style='display:flex;justify-content:center;align-items:center;height:100vh;margin:0'>
                   <div class='g-recaptcha' data-sitekey='{_siteKey}' data-callback='onCaptchaDone'></div>
                   <script>
                       function onCaptchaDone(response) {{
                           // Send the response back to our C# code
                           window.external.CaptchaCompleted(response);
                       }}
                   </script>
               </body>
           </html>";
   
           // Enable communication between the WebBrowser and our C# code
           webBrowser1.ObjectForScripting = new CaptchaCallback(this);
           webBrowser1.DocumentText = captchaHtml;
       }
   
       // Helper class to handle JavaScript callbacks
       [System.Runtime.InteropServices.ComVisible(true)]
       public class CaptchaCallback
       {
           private readonly CaptchaVerificationForm _form;
   
           public CaptchaCallback(CaptchaVerificationForm form)
           {
               _form = form;
           }
   
           public void CaptchaCompleted(string response)
           {
               _form.CaptchaResponse = response;
               _form.DialogResult = DialogResult.OK;
               _form.Close();
           }
       }
   }
   

Step 3: Integrate into Your POST Workflow #

Now tie everything together: check for CAPTCHA, prompt for manual verification if needed, then include the g-recaptcha-response in your form data.

public async Task RunPostWorkflowAsync()
{
   using var client = new HttpClient();
   var targetUrl = "YOUR_TARGET_FORM_URL";
   var formData = new Dictionary<string, string>
   {
       // Add your regular form fields here
       ["email"] = "your_email@example.com",
       ["action"] = "submit_form"
   };

   // Check if CAPTCHA is required
   bool captchaNeeded = await IsCaptchaRequiredAsync(client, targetUrl);
   if (captchaNeeded)
   {
       // Extract the site key from the page
       var pageResponse = await client.GetAsync(targetUrl);
       var htmlContent = await pageResponse.Content.ReadAsStringAsync();
       var htmlDoc = new HtmlDocument();
       htmlDoc.LoadHtml(htmlContent);
       var captchaElement = htmlDoc.DocumentNode.SelectSingleNode("//div[@data-site-key]");
       string siteKey = captchaElement.GetAttributeValue("data-site-key", string.Empty);

       // Show the verification window
       using var captchaForm = new CaptchaVerificationForm(siteKey);
       if (captchaForm.ShowDialog() == DialogResult.OK && !string.IsNullOrEmpty(captchaForm.CaptchaResponse))
       {
           // Add the CAPTCHA token to your form data
           formData["g-recaptcha-response"] = captchaForm.CaptchaResponse;
       }
       else
       {
           Console.WriteLine("CAPTCHA verification cancelled or failed.");
           return;
       }
   }

   // Send the POST request with all form data (including CAPTCHA token if needed)
   var content = new FormUrlEncodedContent(formData);
   var postResponse = await client.PostAsync(targetUrl, content);
   postResponse.EnsureSuccessStatusCode();

   // Process the response as needed
   var result = await postResponse.Content.ReadAsStringAsync();
   Console.WriteLine("POST request succeeded! Response snippet: " + result.Substring(0, 500));
}

Quick Notes #

• reCAPTCHA Version: This example works for reCAPTCHA v2. If the site uses v3 (invisible CAPTCHA), you'll need to adjust the flow to fetch a token via the API instead of showing a widget.
• Browser Compatibility: The WinForms WebBrowser uses IE by default. For better reCAPTCHA support, consider using CefSharp (Chromium Embedded Framework) instead.
• Error Handling: Add try-catch blocks around HTTP requests and HTML parsing to handle network issues or malformed page content.

内容的提问来源于stack exchange，提问作者lucky simon