0 ) {
$mask = ( 0xFF << ( 8 - $rest ) ) & 0xFF;
if ( ( ord( $packed[ $bytes ] ) & $mask ) !== ( ord( $subnet[ $bytes ] ) & $mask ) ) {
continue;
}
}
return true;
}
return false;
}
private static function lock_key( $ip_hash ) {
return self::LOCK_PREFIX . $ip_hash;
}
public static function is_locked( $ip_hash ) {
return (bool) get_transient( self::lock_key( $ip_hash ) );
}
public static function lock( $ip_hash, $minutes ) {
set_transient( self::lock_key( $ip_hash ), time() + $minutes * MINUTE_IN_SECONDS, $minutes * MINUTE_IN_SECONDS );
}
/**
* Hebt die Sperre auf und vergisst die bisherigen Fehlversuche dieser
* Adresse -- sonst sperrte der naechste Tippfehler im selben Zeitfenster
* sofort wieder.
*/
public static function unlock( $ip_hash ) {
delete_transient( self::lock_key( $ip_hash ) );
delete_transient( self::LOSTPASSWORD_PREFIX . $ip_hash );
Wp360_Login_Guard_Database::forget_failures_for_hash( $ip_hash );
}
/**
* Listet aktuell gesperrte IP-Hashes samt Ablaufzeit -- direkter
* Options-Scan, weil die Transients-API selbst kein "alle mit Prefix X"
* anbietet. Das ist fuer die kleine erwartete Anzahl aktiver Sperren
* unproblematisch.
*/
public static function locked_entries() {
global $wpdb;
$rows = $wpdb->get_results($wpdb->prepare( // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- plugineigene Tabelle, Abfragen sind vorbereitet; ein Login-Protokoll darf nicht gecacht werden.
"SELECT option_name, option_value FROM {$wpdb->options} WHERE option_name LIKE %s", // phpcs:ignore
$wpdb->esc_like( '_transient_timeout_' . self::LOCK_PREFIX ) . '%'
));
$entries = array();
foreach ( $rows as $row ) {
// Abgelaufene Transients bleiben bis zur taeglichen Bereinigung in
// der Tabelle stehen -- sie zaehlen nicht mehr als Sperre.
if ( (int) $row->option_value <= time() ) {
continue;
}
$ip_hash = substr( $row->option_name, strlen( '_transient_timeout_' . self::LOCK_PREFIX ) );
$entries[ $ip_hash ] = (int) $row->option_value;
}
return $entries;
}
private static function allow_blocklist_status( $ip ) {
return '';
}
/**
* Weist Anmeldeversuche ab, wenn die anfragende IP aktuell gesperrt ist
* oder (PRO) auf der festen Blockliste steht. Eine bereits vorhandene
* WP_Error-Antwort aus einem frueheren Callback wird nie ueberschrieben,
* damit dessen Fehlermeldung erhalten bleibt. Ein bereits ermittelter
* WP_User dagegen SCHON: WordPress-Core verwirft bei Prioritaet 20 den
* frueh (Prioritaet 1) gesetzten Sperr-Fehler und liefert bei korrektem
* Passwort trotzdem den Benutzer -- ohne diese Pruefung am Kettenende
* (PHP_INT_MAX) liess die Sperre jeden Login mit richtigen Zugangsdaten
* durch und wies nur falsche Passwoerter ab, die WordPress ohnehin ablehnt.
*/
public static function block_if_locked( $user, $username, $password ) {
// Eigene Fehler und leere Felder bleiben unangetastet. WordPress-Cores
// invalid_username/incorrect_password (bzw. die generische Meldung aus
// genericize_error()) werden dagegen bei gesperrter IP ersetzt -- sonst
// erfuehre eine gesperrte IP nie von ihrer Sperre, weil Core den
// fruehen Sperr-Fehler bei Prioritaet 20 immer ueberschreibt.
if ( is_wp_error( $user ) && in_array( $user->get_error_code(), array( 'wp360_lg_locked', 'wp360_lg_blocked', 'empty_username', 'empty_password' ), true ) ) {
return $user;
}
if ( '' === trim( (string) $username ) ) {
return $user;
}
$error = self::access_error( self::canonical_username( $username ) );
return $error ? $error : $user;
}
/** Name des unsichtbaren Formularfelds -- neutral gewaehlt, damit Passwort-Manager es nicht fuer ein Adressfeld halten. */
const HONEYPOT_FIELD = 'wp360_lg_hp';
/**
* Unsichtbares Feld im Anmeldeformular. Menschen sehen und fuellen es nie
* aus, Bots, die jedes Feld belegen, schon. Aus dem Sichtbereich geschoben
* statt mit display:none, weil manche Bots versteckte Felder ueberspringen;
* aria-hidden, tabindex und autocomplete halten es aus Screenreadern, der
* Tab-Reihenfolge und der Autofill-Funktion der Passwort-Manager heraus.
*/
public static function render_honeypot_field() {
if ( ! Wp360_Login_Guard_Settings::get()['honeypot'] ) {
return;
}
?>
' . esc_html__( 'Error:', '360-orbit-login-guard' ) . ' ' . esc_html__( 'Incorrect username or password.', '360-orbit-login-guard' ) );
}
/**
* Fuehrt eine Eingabe im Anmeldefeld auf den Benutzernamen zurueck.
* WordPress erlaubt die Anmeldung mit Benutzername ODER E-Mail-Adresse,
* protokolliert einen Erfolg aber immer unter user_login. Ohne diese
* Angleichung fanden die Ausnahmen (eigene Adresse, eigenes Konto) bei
* einer Anmeldung per E-Mail nie einen Treffer, und die Sperre je Konto
* liesse sich umgehen, indem man abwechselnd Name und Adresse eingibt.
*/
public static function canonical_username( $input ) {
$input = trim( (string) $input );
if ( '' === $input ) {
return '';
}
$user = get_user_by( 'login', $input );
if ( ! $user && str_contains( $input, '@' ) ) {
$user = get_user_by( 'email', $input );
}
return $user ? $user->user_login : $input;
}
/**
* Sperr-/Blocklisten-Fehler fuer die anfragende IP, oder null, wenn sie
* sich anmelden darf. Oeffentlich, weil auch der Zwei-Faktor-Schritt
* (class-two-factor.php) dieselbe Pruefung braucht: Er beendet die
* Anfrage mit exit, bevor block_if_locked() bei PHP_INT_MAX laeuft.
*
* @param string $username Angegebener Benutzername, fuer die Sperre je Konto.
* @return WP_Error|null
*/
public static function access_error( $username = '' ) {
$ip = self::client_ip();
$status = self::allow_blocklist_status( $ip );
if ( 'allowed' === $status ) {
return null;
}
if ( 'blocked' === $status ) {
return new WP_Error( 'wp360_lg_blocked', __( 'Error: This IP address is not allowed to sign in.', '360-orbit-login-guard' ) );
}
$ip_hash = Wp360_Login_Guard_Database::hash_ip( $ip );
$locked = self::is_locked( $ip_hash ) && ! self::exemption_applies( $ip_hash, $username, true );
// Sperre je Konto, ueber alle IPs hinweg -- greift nicht fuer die
// Adresse, von der aus sich genau diese Person zuletzt angemeldet hat.
// So kann ein Angreifer ein fremdes Konto nicht dauerhaft aussperren.
// Konten mit eingerichteter Zwei-Faktor-Anmeldung sind ausgenommen:
// Ein erratenes Passwort allein bringt dort niemanden hinein, und der
// Code-Schritt hat eine eigene Grenze je Konto -- aussperren liessen
// sich solche Konten sonst trotzdem.
if ( ! $locked && '' !== $username && self::is_username_locked( $username ) && ! self::has_two_factor( $username ) ) {
$locked = ! self::exemption_applies( $ip_hash, $username, false );
}
if ( $locked ) {
return new WP_Error( 'wp360_lg_locked', __( 'Error: Too many failed login attempts. Please try again later.', '360-orbit-login-guard' ) );
}
return null;
}
/** Fehlversuche je Konto (ueber alle IPs) bis zur Sperre, als Vielfaches der Grenze je IP. */
const USERNAME_LOCK_FACTOR = 4;
/**
* Die Ausnahmen fuer die eigene Adresse einer Person (siehe
* exemption_applies()) gelten nur bis zu diesem Vielfachen der Grenze je
* IP: grosszuegig genug fuer Tippfehler, aber nicht unbegrenzt -- sonst
* koennte jemand, der sich die Adresse teilt (Buero, Mobilfunk-NAT), das
* Passwort des Kontos ohne Ende durchprobieren.
*/
const EXEMPT_ATTEMPT_FACTOR = 10;
/** Laenger als diese Minuten dauert eine Sperre je Konto nie -- ein Angreifer soll fremde Konten nicht lange aussperren koennen. */
const USERNAME_LOCK_MAX_MINUTES = 15;
const LOSTPASSWORD_PREFIX = 'wp360_lg_lp_';
/**
* Ob die Ausnahme fuer die eigene Adresse einer Person greift: Sie hat sich
* von dieser Adresse aus kuerzlich erfolgreich angemeldet (bei $admin_only
* nur als Administrator) UND hat von dort nicht schon unverhaeltnismaessig
* viele Fehlversuche gesammelt.
*/
private static function exemption_applies( $ip_hash, $username, $admin_only ) {
$known = $admin_only
? Wp360_Login_Guard_Database::has_recent_admin_login( $ip_hash, $username )
: Wp360_Login_Guard_Database::has_recent_login( $ip_hash, $username );
if ( ! $known ) {
return false;
}
$settings = Wp360_Login_Guard_Settings::get();
return Wp360_Login_Guard_Database::failed_count_since( $ip_hash, $settings['window_minutes'] ) < $settings['max_attempts'] * self::EXEMPT_ATTEMPT_FACTOR;
}
const USERNAME_LOCK_PREFIX = 'wp360_lg_ulock_';
private static function username_lock_key( $username ) {
return self::USERNAME_LOCK_PREFIX . md5( strtolower( trim( (string) $username ) ) );
}
private static function is_username_locked( $username ) {
return (bool) get_transient( self::username_lock_key( $username ) );
}
private static function has_two_factor( $username ) {
return false;
}
/**
* Aktuell gesperrte Konten fuer den Status-Tab: Schluessel => [Benutzername, Ablauf].
*
* @return array
*/
public static function locked_accounts() {
global $wpdb;
$rows = $wpdb->get_results($wpdb->prepare( // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Transient-Scan, siehe locked_entries().
"SELECT option_name, option_value FROM {$wpdb->options} WHERE option_name LIKE %s", // phpcs:ignore
$wpdb->esc_like( '_transient_timeout_' . self::USERNAME_LOCK_PREFIX ) . '%'
));
$entries = array();
foreach ( $rows as $row ) {
if ( (int) $row->option_value <= time() ) {
continue;
}
$key = substr( $row->option_name, strlen( '_transient_timeout_' . self::USERNAME_LOCK_PREFIX ) );
$username = get_transient( self::USERNAME_LOCK_PREFIX . $key );
if ( is_string( $username ) && '' !== $username ) {
$entries[ $key ] = array(
'username' => $username,
'until' => (int) $row->option_value,
);
}
}
return $entries;
}
/** Hebt die Kontosperre auf -- $key ist der md5-Teil aus locked_accounts(). */
public static function unlock_account( $key ) {
$username = get_transient( self::USERNAME_LOCK_PREFIX . $key );
delete_transient( self::USERNAME_LOCK_PREFIX . $key );
// Auch die Fehlversuche vergessen, sonst sperrte der naechste
// Tippfehler das Konto sofort wieder.
if ( is_string( $username ) && '' !== $username ) {
Wp360_Login_Guard_Database::forget_failures_for_username( $username );
}
}
public static function unlock_username( $username ) {
$username = self::canonical_username( $username );
delete_transient( self::username_lock_key( $username ) );
Wp360_Login_Guard_Database::forget_failures_for_username( $username );
}
/**
* Zaehlt einen Fehlversuch ausserhalb der authenticate-Kette (z. B. einen
* falschen Zwei-Faktor-Code) in DERSELBEN Sperre wie ein falsches Passwort.
*/
public static function register_failure( $username ) {
$ip_hash = Wp360_Login_Guard_Database::hash_ip( self::client_ip() );
Wp360_Login_Guard_Database::record( $ip_hash, $username, false );
self::maybe_lock( $ip_hash, $username );
}
public static function on_login_failed( $username, $error = null ) {
$ip_hash = Wp360_Login_Guard_Database::hash_ip( self::client_ip() );
$username = self::canonical_username( $username );
// Ein Fehlschlag, der bereits von block_if_locked() selbst kommt
// (wp360_lg_locked/wp360_lg_blocked), wuerde sonst die eigene Sperre
// immer wieder verlaengern -- den zaehlen wir nicht erneut mit.
if ( is_wp_error( $error ) && in_array( $error->get_error_code(), array( 'wp360_lg_locked', 'wp360_lg_blocked', 'wp360_lg_pending' ), true ) ) {
return;
}
Wp360_Login_Guard_Database::record( $ip_hash, $username, false );
self::maybe_lock( $ip_hash, $username );
}
private static function maybe_lock( $ip_hash, $username = '' ) {
$settings = Wp360_Login_Guard_Settings::get();
// Nur fuer Konten, die es gibt: Zu erfundenen Namen gibt es nichts zu
// schuetzen, und die Eingabe (oft ein versehentlich getipptes Passwort)
// soll nicht als Sperre im Klartext gespeichert werden.
if ( '' !== $username && ! self::is_username_locked( $username ) && false !== get_user_by( 'login', $username )
&& Wp360_Login_Guard_Database::failed_count_for_username_since( $username, $settings['window_minutes'] ) >= $settings['max_attempts'] * self::USERNAME_LOCK_FACTOR ) {
// Wert = Benutzername, damit der Status-Tab die Sperre anzeigen kann.
// Hoechstens USERNAME_LOCK_MAX_MINUTES: Wer fremde Konten gezielt
// sperren will, soll sie nicht lange blockieren koennen.
set_transient( self::username_lock_key( $username ), mb_substr( $username, 0, 60 ), min( $settings['lockout_minutes'], self::USERNAME_LOCK_MAX_MINUTES ) * MINUTE_IN_SECONDS );
}
if ( self::is_locked( $ip_hash ) ) {
return;
}
// Sicherheitsnetz: Tippt sich eine Person mit manage_options von einer
// Adresse aus, von der sie sich kuerzlich erfolgreich angemeldet hat,
// beim EIGENEN Konto vertippt, sperrt das die IP erst bei einem
// Vielfachen der Grenze (EXEMPT_ATTEMPT_FACTOR) -- niemand soll sich
// aus wp-admin aussperren, aber unbegrenzt darf es nicht sein.
// Fehlversuche fuer andere Konten von derselben Adresse zaehlen
// dagegen normal.
$threshold = $settings['max_attempts'];
if ( Wp360_Login_Guard_Database::has_recent_admin_login( $ip_hash, $username ) ) {
$threshold *= self::EXEMPT_ATTEMPT_FACTOR;
}
$failures = Wp360_Login_Guard_Database::failed_count_since( $ip_hash, $settings['window_minutes'] );
if ( $failures < $threshold ) {
return;
}
self::lock( $ip_hash, $settings['lockout_minutes'] );
if ( $settings['notify_admin_email'] ) {
self::notify_lockout( $ip_hash, $failures );
}
}
private static function notify_lockout( $ip_hash, $failures ) {
// Hoechstens eine Mail je Stunde: Mit wechselnden Adressen loeste ein
// Angreifer sonst alle paar Anfragen eine neue aus. Die Uebersicht in
// wp-admin zeigt ohnehin alle aktiven Sperren.
if ( get_transient( 'wp360_lg_lockout_mail_sent' ) ) {
return;
}
set_transient( 'wp360_lg_lockout_mail_sent', 1, HOUR_IN_SECONDS );
wp_mail(
get_option( 'admin_email' ),
sprintf(
/* translators: %s: site name */
__( '[%s] Login Guard: IP address locked out', '360-orbit-login-guard' ),
get_bloginfo( 'name' )
),
sprintf(
/* translators: 1: number of failed attempts, 2: fingerprint id, used only to identify the entry in wp-admin, never a real IP address */
__( "An IP address was locked out after %1\$d failed login attempts.\n\nFingerprint: %2\$s\nManage lockouts: %3\$s", '360-orbit-login-guard' ),
$failures,
substr( $ip_hash, 0, 12 ),
admin_url( 'admin.php?page=wp360-login-guard' )
)
);
}
public static function on_login_success( $username, $user ) {
$ip_hash = Wp360_Login_Guard_Database::hash_ip( self::client_ip() );
Wp360_Login_Guard_Database::record( $ip_hash, $username, true );
}
/**
* Ersetzt die Standard-WordPress-Fehlermeldung (die verraet, ob ein
* Benutzername ueberhaupt existiert) durch eine generische -- eigene
* Fehlercodes (Sperre, Blockliste, leeres Feld) bleiben unveraendert,
* damit die jeweils richtige, hilfreiche Meldung angezeigt wird.
*/
public static function genericize_error( $user ) {
if ( ! is_wp_error( $user ) ) {
return $user;
}
if ( ! Wp360_Login_Guard_Settings::get()['generic_errors'] ) {
return $user;
}
$leave_as_is = array( 'wp360_lg_locked', 'wp360_lg_blocked', 'wp360_lg_pending', 'empty_username', 'empty_password' );
if ( in_array( $user->get_error_code(), $leave_as_is, true ) ) {
return $user;
}
return new WP_Error( 'wp360_lg_generic', '' . esc_html__( 'Error:', '360-orbit-login-guard' ) . ' ' . esc_html__( 'Incorrect username or password.', '360-orbit-login-guard' ) );
}
/**
* WordPress' eigener retrieve_password()-Ablauf (wp-login.php?action=
* lostpassword) laeuft komplett unabhaengig von der authenticate-Filterkette
* -- eine gesperrte IP konnte hierueber bislang trotzdem beliebig viele
* Zuruecksetzungs-Anfragen fuer beliebige Benutzernamen stellen. Jede
* Anfrage fuer einen NICHT existierenden Benutzernamen zaehlt als
* Fehlversuch in DERSELBEN Sperre wie ein falsches Passwort -- das ist
* Benutzername-Enumeration, dieselbe Art Missbrauch, gegen die die
* Login-Sperre ohnehin schuetzt. Eine Anfrage fuer einen ECHTEN Account
* zaehlt bewusst NICHT mit: anders als bei wp-login.php sperrt eine
* Sperre hier auch den normalen Login desselben Nutzers, und ein Mensch,
* der z. B. die Mail nicht bekommt und mehrfach auf "erneut senden"
* klickt, ist kein Angriff. $errors ist ein Objekt (per Handle
* uebergeben) -- add() darauf wirkt sich auch ohne Referenz-Parameter auf
* den Aufrufer aus; enthaelt $errors danach Fehler, bricht WordPress selbst
* die Zuruecksetzung ab (siehe wp-includes/user.php::retrieve_password()).
*/
public static function guard_lostpassword( $errors, $user_data ) {
$ip = self::client_ip();
$status = self::allow_blocklist_status( $ip );
if ( 'allowed' === $status ) {
return;
}
if ( 'blocked' === $status ) {
$errors->add( 'wp360_lg_blocked', __( 'Error: This IP address is not allowed to sign in.', '360-orbit-login-guard' ) );
return;
}
$ip_hash = Wp360_Login_Guard_Database::hash_ip( $ip );
if ( self::is_locked( $ip_hash ) ) {
$errors->add( 'wp360_lg_locked', __( 'Error: Too many failed login attempts. Please try again later.', '360-orbit-login-guard' ) );
return;
}
// Jede Anfrage zaehlt gleich, ob der Name existiert oder nicht -- sonst
// verriete die Sperrmeldung nach ein paar Versuchen, welche Namen es
// gibt. Dafuer ein eigener, groesserer Zaehler: Wer mehrfach auf "erneut
// senden" klickt, soll nicht schon beim Login gesperrt sein.
$settings = Wp360_Login_Guard_Settings::get();
$window = $settings['window_minutes'] * MINUTE_IN_SECONDS;
$state = get_transient( self::LOSTPASSWORD_PREFIX . $ip_hash );
if ( ! is_array( $state ) || ( $state['since'] ?? 0 ) < time() - $window ) {
$state = array(
'n' => 0,
'since' => time(),
);
}
++$state['n'];
set_transient( self::LOSTPASSWORD_PREFIX . $ip_hash, $state, $window );
if ( $state['n'] >= $settings['max_attempts'] * 2 ) {
self::lock( $ip_hash, $settings['lockout_minutes'] );
}
if ( $user_data ) {
return;
}
$login = isset( $_POST['user_login'] ) ? sanitize_text_field( wp_unslash( $_POST['user_login'] ) ) : ''; // phpcs:ignore WordPress.Security.NonceVerification.Missing
// WordPress meldet bei einem unbekannten Namen "Kein Konto", bei einem
// bekannten leitet es auf "E-Mail verschickt" weiter -- am Unterschied
// laesst sich ablesen, welche Konten es gibt. Mit generischen
// Fehlermeldungen bekommt ein unbekannter Name dieselbe Antwort wie ein
// bekannter. Nur im Anmeldeformular, nicht bei Aufrufen aus wp-admin.
if ( Wp360_Login_Guard_Settings::get()['generic_errors'] && did_action( 'login_init' ) && '' !== $login && ! $errors->has_errors() ) {
wp_safe_redirect( add_query_arg( 'checkemail', 'confirm', wp_login_url() ) );
exit;
}
}
/**
* Zaehlt einen fehlgeschlagenen Anwendungspasswort-Versuch (REST/
* Basic-Auth) in DERSELBEN Sperre wie ein falsches wp-login.php-Passwort.
* `application_password_failed_authentication` feuert bei jeder Art von
* Fehlschlag (unbekannter Benutzername, deaktiviert, falsches Passwort --
* siehe wp-includes/user.php::wp_authenticate_application_password()).
*/
public static function on_application_password_failed( $error ) {
$ip_hash = Wp360_Login_Guard_Database::hash_ip( self::client_ip() );
Wp360_Login_Guard_Database::record( $ip_hash, '(application password)', false );
self::maybe_lock( $ip_hash );
}
/**
* Erfolgs-Gegenstueck zu on_application_password_failed(): ohne einen
* Erfolgs-Eintrag saehe has_recent_admin_login() (das Sicherheitsnetz
* gegen versehentlichen Admin-Lockout) nie einen Treffer fuer IP-Hashes,
* die sich ausschliesslich per Anwendungspasswort anmelden (z. B. eine
* CI-Pipeline oder eine mobile App) -- wp_login feuert fuer diesen Weg
* nicht, also wuerde on_login_success() nie laufen.
*/
public static function on_application_password_success( $user ) {
if ( ! $user instanceof WP_User ) {
return;
}
$ip_hash = Wp360_Login_Guard_Database::hash_ip( self::client_ip() );
// Jede API-Anfrage meldet einen Erfolg -- hoechstens einmal pro Stunde
// und Konto/Adresse eintragen, sonst fuellt ein API-lastiger Betrieb
// den Verlauf und verdraengt die Fehlversuche.
$throttle = 'wp360_lg_apw_' . md5( $ip_hash . '|' . $user->user_login );
if ( get_transient( $throttle ) ) {
return;
}
set_transient( $throttle, 1, HOUR_IN_SECONDS );
Wp360_Login_Guard_Database::record( $ip_hash, $user->user_login, true );
}
/**
* Weist eine bereits gesperrte/blockierte IP ab, BEVOR das eigentliche
* Anwendungspasswort ueberhaupt geprueft wird -- ohne das liefe die Sperre
* fuer diesen Weg leer: waehrend der Sperrzeit koennten weiterhin beliebig
* viele Passwoerter durchprobiert werden, nur eben weiterhin mitgezaehlt
* statt tatsaechlich verhindert. `false` laesst
* wp_authenticate_application_password() die Anfrage unbeachtet
* (siehe deren application_password_is_api_request-Pruefung) statt sie zu
* pruefen -- die Anfrage laeuft dann anonym weiter, wie bei jedem falschen
* Anwendungspasswort auch.
*/
public static function block_application_password_if_locked( $is_api_request ) {
if ( ! $is_api_request ) {
return $is_api_request;
}
$ip = self::client_ip();
$status = self::allow_blocklist_status( $ip );
if ( 'allowed' === $status ) {
return $is_api_request;
}
if ( 'blocked' === $status ) {
return false;
}
$ip_hash = Wp360_Login_Guard_Database::hash_ip( $ip );
return self::is_locked( $ip_hash ) ? false : $is_api_request;
}
}