web-dev-qa-db-fra.com

WordPress 'is_user_logged_in () est-il sécurisé?

Je m'interroge depuis un moment sur ce sujet. La déclaration if suivante est-elle suffisamment sûre? Est-il facile de percer le code et d’avoir accès au contenu s’il n’est pas connecté?

<?php if ( is_user_logged_in() ) { 
     // SECURE CONTENT
} else { 
     // LANDING PAGE
} ?>
user-rolesuser-access
4
Frederick Andersen

Eh bien, vous devez vous demander "assez en sécurité pour quoi?" Je doute que vous soyez une banque ou une autre institution qui a besoin d'une sécurité exceptionnellement élevée. Si vous étiez vous auriez une équipe de 100 000 $ + par an experts pour répondre à cette question pour vous.

Dans cet esprit...

Il vous faudrait renverser le système de connexion WordPress pour dépasser ce code. Je suis sûr que c'est possible, mais si vos mots de passe sont solides, cela devrait être assez difficile. Ce ne sera pas un hack "mettre un octet nul dans la chaîne de requête". Il devrait être suffisamment sécurisé pour la plupart des objectifs.

Ce qui est préoccupant, c’est que is_user_logged_in et wp_get_current_user dont il dépend, sont tous deux enfichables (ce qui me semble insensé), ce qui signifie qu’un plugin malveillant, ou tout simplement mal écrit, pourrait détruire complètement votre sécurité.

4
s_ha_dum

En bref - et pour un usage général - oui. Comme @s_ha_dum l'a fait remarquer, cela dépend vraiment de l'utilisation que vous en faites.

La fonction est-elle sécurisée?

Comme @kaiser et @s_ha_dum l'ont mentionné, la fonction est connectable, ce qui signifie que tout plug-in (bien que not themes) puisse le redéfinir pour qu'il fasse quoi que ce soit. Mais ce n'est pas vraiment un problème dans la mesure où ces plug-ins peuvent faire presque n'importe quoi - ils exécutent du code sur votre serveur.

Le fait qu'il soit "enfichable" n'est pas vraiment le problème ici. Vous devez vous assurer que all plugins - et les thèmes - que vous utilisez sont raisonnablement fiables. Lorsque la sécurité est vitale, les entreprises auront tendance à créer leurs propres plug-ins et à n'utiliser que ceux-ci.

(Le fait qu’il soit enfichable permet aux entreprises de mettre en place un système d’authentification plus sécurisé, le cas échéant).

La méthode d'authentification est-elle sécurisée?

Supposons que la fonction est définie comme dans le noyau WordPress. Est-ce sécurisé? (Oui).

La fonction is_user_logged_in() recherche dans le navigateur de l'utilisateur un cookie valide. Si ce n'est pas là, est invalide ou a expiré - ils sont obligés de se connecter à nouveau.

Le cookie est généré à partir des éléments suivants:

  • Nom d'utilisateur de l'utilisateur
  • 8 caractères pris de leur mot de passe hash
  • Horodatage de l'expiration du cookie

Le cookee lui-même contient le nom d'utilisateur et l'horodatage en texte brut. Il contient également un HMAC ( code d’authentification du message de hachage ) - c’est une partie difficile à deviner, qui dépend du nom d’utilisateur et de l’horodatage. Ainsi, si un attaquant met la main sur un cookie expiré ou sur son propre compte, il ne peut pas produire de cookie valide qui les connecte à un compte administrateur sans produire un HMAC valide.

Le HMAC est produit à partir d'un hachage des 3 éléments ci-dessus. Maintenant, 8 caractères ne semblent pas beaucoup - cela pourrait être forcé brute dans une semaine. Mais en fait, le hash est un salted hash - utilisant les SELS de votre site. Avec cela, et tant qu'ils sont en sécurité, toutes les tentatives de forçage brutal sont déjouées.

... si bien que la sécurité de cette fonction réside dans la sécurité des DALT de votre site Web. Ceux-ci sont stockés dans votre wp-config.php, avec vos informations d'identification de base de données.Vous ne devriez jamais rendre cela public.

Puis-je détecter si une fonction a modifié la définition d'une fonction enfichable?

La fonction ci-dessus de Kaiser ne fonctionne que si un plug-in MU a écrasé une fonction. Voici une solution plus générale, avec la clause de non-responsabilité selon laquelle un plug-in ne remplaçant pas une fonction plug-in estnot/, ce qui indique que vos plug-ins sont sécurisés.

/**
 * Do not use in production.
 * 
 * Checks if any plug-ins have overwritten a pluggable function in 
 * `wp-includes/pluggable.php` with a custom function.
 * 
 * Prints list and kills processing if a function has been overwritten.
 * 
 * Based on Kaiser's answer (link below).
 * @link http://wordpress.stackexchange.com/questions/105637/is-wordpress-is-user-logged-in-secure/105667#105667
 */
function wpse105637_was_pluggable_defined_by_plugin(){

    $arr = token_get_all( file_get_contents( ABSPATH.WPINC.'/pluggable.php' ) );
    $functions = array();
    foreach ( $arr as $curr_key => $part ){
        if ( ! is_array( $part ) )
            continue;

        if ( token_name( $part[0] ) === 'T_FUNCTION' ){
            while ( is_array( $arr[ $curr_key ] ) AND 'T_FUNCTION' !== $arr[ $curr_key ][0] )
                ++$curr_key;
            $functions[] = $arr[ --$curr_key ][1];
        }
    }

    $overwritten  = 0;
    foreach ( $functions as $f ){
        $reflFunc = new ReflectionFunction( $f );
        if( ABSPATH.WPINC.'/pluggable.php' !== $reflFunc->getFileName() ){
            $overwritten++;
            printf( '<h1> Functions Overwritten </h1>' );
            print '<code>'.$f .'</code> ' . $reflFunc->getFileName() . ':' . $reflFunc->getStartLine() . '<br/>';
        }
    }

    if( $overwritten )
        wp_die( sprintf( '%d pluggable functions overwritten', $overwritten ) );

}
add_action( 'plugins_loaded', 'wpse105637_was_pluggable_defined_by_plugin' );
6
Stephen Harris

Fonctions enfichables

Tout d’abord, les plug-ins sont chargés à partir du fichier ~/wp-settings.php. Ils sont inclus après que tous les fichiers de plug-in aient été inclus (maisavantplugins_loaded) afin que tout plugin puisse les remplacer. (mu-plugins sont inclus même plus tôt, ils ont donc la priorité).

Obstacles pour un hack

L’utilisateur par défaut ne s’inquiètera jamais de cela, car il n’aura peut-être même pas de dossier muplugins, car il n’est pas ajouté par défaut par défaut. Donc, la première chose que le "pirate informatique" doit faire est d’ajouter le dossier. Cela signifie qu'il (s) a déjà accès à votre système de fichiers et que vous rencontrez des problèmes complètement différents d'un piratage sur votre système installé. Aucun pirate informatique sérieux ne s'embarrasserait maintenant de WordPress lorsque toutes les portes plus faciles d'accès sont largement ouvertes. Il suffit donc de vérifier si WPMU_PLUGIN_DIR et WPMU_PLUGIN_URL sont définis. Si ce n'est pas le cas, vous n'avez pas à vous inquiéter.

La prochaine chose à faire - au cas où vous auriez un dossier muplugins -, vous voudrez vérifier ces fichiers. C'est assez simple: les plug-ins MU ne fonctionnent que comme des plug-ins de fichier. Donc, si vous avez plus de plugins que de fichiers, alors l'un de vos fichiers charge déjà des fichiers externes. Vous pouvez facilement contrôler cela en comptant le nombre total de fichiers avec get_included_files() sur le hook muplugins_loaded à la priorité 0, puis comparez à nouveau le compte aux fichiers inclus sur le plugins_loaded- hook à la priorité 0. La différence doit être égale à ce que vous recevez

count( glob( WPMU_PLUGIN_DIR.'/*.php' ) );

La dernière chose à craindre.

Donc, disons que quelqu'un a vraiment réussi à vous remettre un plug-in MU (que vous deviez installer vous-même après avoir ajouté le dossier vous-même), alors il est temps de surveiller si l'une des fonctions enfichables a été remplacée. Vous pouvez utiliser le plugin ci-dessous pour le faire. Ce sera simplement die() dans tous les cas où l’une de vos fonctions a été remplacée - la "protection" de vos visiteurs. Il se connecte le plus tard possible (il n'y a pas de véritable "dernier" en priorité de hook), lit toutes les fonctions du fichier enfichable, puis vérifie leur existence. Comme il ne saisit que le contenu du fichier, il n'est pas inclus et donc ces fonctions ne seront pas définies. De cette façon, vous pouvez être sûr que le plug-in MU restera toujours à jour, car le nombre de fonctions peut changer, mais le plug-in le saura tout de même.

Gardez à l'esprit que les plugins ont besoin d'au moins PHP version 5.3.

<?php
defined( 'ABSPATH' ) OR exit;
/**
 * Plugin Name: (#105637) Check pluggable changes
 */
add_action( 'muplugins_loaded', 'wpse_pluggable_check', pow( 99, 99 ) );
function wpse_pluggable_check()
{
    $arr = token_get_all( file_get_contents( ABSPATH.WPINC.'/pluggable.php' ) );
    $functions = array();
    foreach ( $arr as $curr_key => $part )
    {
        if ( ! is_array( $part ) )
            continue;

        $token = token_name( array_shift( $part ) );
        $token === 'T_FUNCTION'
            AND $functions[] = $arr[ $curr_key + 2 ][1];
    }
    foreach ( $functions as $f )
        function_exists( $f ) AND wp_die( 'pluggable overwritten!' );
}

Le plugin ci-dessus suppose que le schéma de fonction est toujours function fn_name() {. Voici une version légèrement améliorée qui effectue une recherche dans les tableaux suivants.

$arr = token_get_all( file_get_contents( ABSPATH.WPINC.'/pluggable.php' ) );
$functions = array();
foreach ( $arr as $curr_key => $part )
{
    if ( ! is_array( $part ) )
        continue;

    if ( token_name( $part[0] ) === 'T_FUNCTION' )
    {
        while ( is_array( $arr[ $curr_key ] ) AND 'T_FUNCTION' !== $arr[ $curr_key ][0] )
            ++$curr_key;
        $functions[] = $arr[ --$curr_key ][1];
    }
}
foreach ( $functions as $f )
    function_exists( $f ) AND wp_die( 'pluggable overwritten!' );
4
kaiser