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; } }