Sicurezza - nuovo criptaggio Password Joomla

[myn3craft]

Salve a tutti, passando dalla versione 2.5.x alla 3.x ho notato un piccolo ma radicale cambiamento nello stoccaggio delle password nel database di joomla.
Credo che questo cambiamento sia addirittura stato introdotto in uno degli ultimi update di Joomla 2.5.19 (che era l'ultima versione in cui controllai questo particolare)

come tutti o quasi sappiamo, Joomla (come altri cms ormai) non conserva in chiaro le password salvate ma utilizza un particolare algoritmo di hash ovvero

md5(password+salt):salt

questo è un esempio di password di helloword+ salt random di 32 caratteri

85d9b7362e3c2977d5daec1cc6e771dd:RfT3fY4oLohcRQNkl ZXv0IjUS5Pnj5E
("helloword"+ salt) : salt

verificare quindi la password di un utente era abbastanza semplice tramite php senza scomodare Joomla ma...
dagli ultimi aggironamenti mi sono ritrovato questo una roba simile a questa


$P$DssuWDSsrHZ7iB2aCk5PMA.YefKpeH0

la password qui sopra è sempre helloword codificata però tramite un nuovo algoritmo di hashing..

Spulciando il file helper.php di joomla ho notato tutte le possibilità di stoccaggio delle password e in particolare una parte che serve ad aggiornare tutte le vecchie password md5(psw+salt):salt alla nuova codifica

public static function hashPassword($password)
    {
        // Use PHPass's portable hashes with a cost of 10.
        $phpass = new PasswordHash(10, true);

        return $phpass->HashPassword($password);
    }

    /**
     * Formats a password using the current encryption. If the user ID is given
     * and the hash does not fit the current hashing algorithm, it automatically
     * updates the hash.
     *
     * @param   string   $password  The plaintext password to check.
     * @param   string   $hash      The hash to verify against.
     * @param   integer  $user_id   ID of the user if the password hash should be updated
     *
     * @return  boolean  True if the password and hash match, false otherwise
     *
     * @since   3.2.1
     */

    public static function verifyPassword($password, $hash, $user_id = 0)
    {
        $rehash = false;
        $match = false;

        // If we are using phpass
        if (strpos($hash, '$P$') === 0)
        {
            // Use PHPass's portable hashes with a cost of 10.
            $phpass = new PasswordHash(10, true);

            $match = $phpass->CheckPassword($password, $hash);

            $rehash = false;
        }
        else
        {
            // Check the password
            $parts = explode(':', $hash);
            $crypt = $parts[0];
            $salt  = @$parts[1];

            $rehash = true;

            $testcrypt = md5($password . $salt) . ($salt ? ':' . $salt : '');

            $match = JCrypt::timingSafeCompare($hash, $testcrypt);
        }

        // If we have a match and rehash = true, rehash the password with the current algorithm.
        if ((int) $user_id > 0 && $match && $rehash)
        {
            $user = new JUser($user_id);
            $user->password = self::hashPassword($password);
            $user->save();
        }

        return $match;
    }

    /**
     * Formats a password using the current encryption.
     *
     * @param   string   $plaintext     The plaintext password to encrypt.
     * @param   string   $salt          The salt to use to encrypt the password. []
     *                                  If not present, a new salt will be
     *                                  generated.
     * @param   string   $encryption    The kind of password encryption to use.
     *                                  Defaults to md5-hex.
     * @param   boolean  $show_encrypt  Some password systems prepend the kind of
     *                                  encryption to the crypted password ({SHA},
     *                                  etc). Defaults to false.
     *
     * @return  string  The encrypted password.
     *
     * @since   11.1
     *
     * @deprecated  4.0
     */ 

più in basso sempre nell'helper.php tutte le tipologie possibili di hashing utilizzabili su joomla

case 'plain':
...

case 'sha':    
...

case 'crypt':
...        
    
case 'crypt-des':    
...

case 'crypt-md5':
...

case 'crypt-blowfish':
...

case 'md5-base64':
...

case 'ssha':
...    
    
case 'smd5':
...

case 'aprmd5':
...    

case 'md5-hex':
... 

in un primo momento per non modificare un intero php creato da me per verificare le password degli utenti avrei voluto ritornare alla vecchia codifica, ma con il senno di poi preferisco comprendere come utilizzare questa nuova codifica cosi' da poter comparare le password immesse con quelle salvate, ovvero l'utente inserisce la password, direttamente da php genero l'hash , al massimo prelevo il salt dal database (credo che ci sia anche qui) e comparo hash salvato con quello generato .

Qualcuno di voi sì è già cimentato? riconosce per caso la codifica? Io ho notato una certa somiglianza con queste per via dei caratteri $X$ dove X di solito è una costante che accomuna tutte le password e può essere un qualsiasi carattere alfanumenrico..

Apache CRYPT password hash (advanced authentication)
nel file .htpasswd (username:hash) con salt. Utilizzate su WordPress 3.x

MD5 Crypt hash
$1$in0n33n2$vhiiaIW3I6xgTxsLQE7Ir/

BlowFish Crypt hash
$2a$07$oKunIwJYxdIxzzo6oJGCW.kfe70slf.y1H17ZKuu5FpOyvms7tawe

attendo fiducioso ;) magari ne esce un post abbastanza utile

[karl94]

per non modificare un intero php creato da me per verificare le password degli utenti

Ma perché non puoi usare la funzione verifyPassword di Joomla?

[myn3craft]

essendo una parte del sito indipendente da Joomla preferirei a non affidarmi al suo framework...
modificando con un '/..' lo si può utilizzare anche in una sottocartella della root nel mio caso /script dove su / è installato joomla

per chi voglia utilizzare un login tramite framework do joomla può utilizzare questo:

<?php
    define( '_JEXEC', 1 );
    define('JPATH_BASE', dirname(__FILE__) );                             // se lo script è inserito nella root
// define( 'JPATH_BASE', realpath(dirname(__FILE__).'/..' ));        // se lo script è inserito in una sottocartella della root 
    define( 'DS', DIRECTORY_SEPARATOR );



    require_once( '/includes/defines.php' );
    require_once( '/includes/framework.php' );

    $mainframe =& JFactory::getApplication('site');
    $mainframe->initialise();

    jimport('joomla.user.helper');
    $password = "test";     
    echo "<strong>prova della password: </strong>" . JUserHelper::hashPassword($password);
?>

mancano ovviamente i controlli della password ma il resto è praticamente tutto fatto

[myn3craft]

dopo un bel po di ricerche posso confermare che il nuovo algoritmo di hash utilzzato è il phpass, non ho ancora ben capito come funziona per riuscire a creare un login esterno che non si appoggi al framework di Joomla ma sono riuscito a trovare direttamente dal file di joomla come effettuare il login

<?php
/**
 * Joomla! External authentication script
 *
 * @author vdespa
 * Version 1.0
 *
 * Code adapted from /index.php
 *
 * @package    Joomla.Site
 *
 * @copyright  Copyright (C) 2005 - 2014 Open Source Matters, Inc. All rights reserved.
 * @license    GNU General Public License version 2 or later; see LICENSE.txt
 */

if (version_compare(PHP_VERSION, '5.3.1', '<'))
{
    die('Your host needs to use PHP 5.3.1 or higher to run this version of Joomla!');
}

/**
 * Constant that is checked in included files to prevent direct access.
 * define() is used in the installation folder rather than "const" to not error for PHP 5.2 and lower
 */
define('_JEXEC', 1);

if (file_exists(__DIR__ . '/defines.php'))
{
    include_once __DIR__ . '/defines.php';
}

if (!defined('_JDEFINES'))
{
    define('JPATH_BASE', __DIR__);
    require_once JPATH_BASE . '/includes/defines.php';
}

require_once JPATH_BASE . '/includes/framework.php';

// Instantiate the application.
$app = JFactory::getApplication('site');

// JFactory
require_once (JPATH_BASE .'/libraries/joomla/factory.php');


// Hardcoded for now
$credentials['username'] = 'admin';
$credentials['password'] = 'admin';

/**
 * Code adapted from plugins/authentication/joomla/joomla.php
 *
 * @package     Joomla.Plugin
 * @subpackage  Authentication.joomla
 *
 * @copyright   Copyright (C) 2005 - 2014 Open Source Matters, Inc. All rights reserved.
 * @license     GNU General Public License version 2 or later; see LICENSE.txt
 */

// Get a database object
$db    = JFactory::getDbo();
$query = $db->getQuery(true)
    ->select('id, password')
    ->from('#__users')
    ->where('username=' . $db->quote($credentials['username']));

$db->setQuery($query);
$result = $db->loadObject();

if ($result)
{
    $match = JUserHelper::verifyPassword($credentials['password'], $result->password, $result->id);

    if ($match === true)
    {
        // Bring this in line with the rest of the system
        $user = JUser::getInstance($result->id);
        var_dump($user);
        echo 'Joomla! Authentication was successful!';
    }
    else
    {
        // Invalid password
        // Prmitive error handling
        die('Invalid password');
    }
} else {
    // Invalid user
    // Prmitive error handling
    die('Cound not find user in the database');
}

Il suddetto codice è stato testato e funziona correttamente anche su Joomla 2.5.19 e successivi
per un login senza l'utilizzo del framework joomla è invece necessario includere il file libreries/phpass/PasswordHash.php

e sperimentare un po' con i metodi messi a disposizione.. dalle mie prove sono riuscito a creare correttamente un nuovo hash a partire da una password in chiaro, questa avrà sempre la prima parte uguale a tutte le altre in questo caso $P$ il resto devo ancora capire come identificare l'eventuale salt che sarà poi concatenato in qualche modo (prima o dopo) alla nostra password in chiaro.. Non sono un esperto della sintassi php quindi un reverse del codice per me è un po' arduo :P se qualcuno si vuole cimentare potrebbe essere veramente di aiuto!