Method test_boolean_based

src/sql_injection_scanner.rs:141–202

(
        &self,
        client: &reqwest::Client,
        url: &Url,
        true_payload: &str,
        false_payload: &str,
        param_index: usize,
        pb: &ProgressBar,
    )

                        .await?
                    {
                        break;
                    }
                }
            }
        }
        Ok(())
    }

    async fn test_boolean_based(
        &self,
        client: &reqwest::Client,
        url: &Url,
        true_payload: &str,
        false_payload: &str,
        param_index: usize,
        pb: &ProgressBar,
    ) -> Result<bool, reqwest::Error> {
        let query_pairs: Vec<(String, String)> = url.query_pairs().into_owned().collect();
        let tested_param = query_pairs[param_index].0.clone();
        let true_url = inject_query_param(url, param_index, |value| format!("{}{}", value, true_payload));
        let false_url = inject_query_param(url, param_index, |value| format!("{}{}", value, false_payload));

        self.rate_limiter.wait().await;
        if let (Some(true_response), Some(false_response)) = (
            self.send_get_request(client, &true_url).await,
            self.send_get_request(client, &false_url).await,
        ) {
            if let (Ok(true_body), Ok(false_body)) =
                (true_response.text().await, false_response.text().await)
            {
                // Diff normalized bodies: raw responses differ on every request
                // (random request IDs, CSRF tokens, timestamps) and on reflected
                // payload echoes, so a naive != comparison false-positives on
                // any dynamic page (verified against freebuff.com).
                let true_norm = normalize_boolean_body(&true_body, true_payload);
                let false_norm = normalize_boolean_body(&false_body, false_payload);
                if true_norm != false_norm {
                    let vuln = SqlInjectionVulnerability {
                        url: url.clone(),
                        parameter: tested_param.clone(),
                        payload: format!("{} / {}", true_payload, false_payload),
                        vuln_type: "Boolean-Based".to_string(),
                    };
                    println!(
                        "[+] SQL Injection Found: {} in {}",
                        vuln.payload, vuln.parameter
                    );
                    self.reporter.report_sql_injection(&vuln);
                    return Ok(true);
                }
            }
        }
        pb.inc(2);
        Ok(false)
    }

    async fn measure_url_time(
        &self,