Foros del Web » Creando para Internet » Sistemas de gestión de contenidos »

Encriptación de contraseña en phpBB 3.0?

Estas en el tema de Encriptación de contraseña en phpBB 3.0? en el foro de Sistemas de gestión de contenidos en Foros del Web. Encriptación de contraseña en phpBB 3.0? Hola buena gente. A ver si alguien me puede echar una mano en este asunto. Tengo un sitio web, ...
  #1 (permalink)  
Antiguo 16/02/2008, 15:34
 
Fecha de Ingreso: junio-2007
Mensajes: 76
Antigüedad: 13 años, 4 meses
Puntos: 1
Exclamación Encriptación de contraseña en phpBB 3.0?

Encriptación de contraseña en phpBB 3.0?

Hola buena gente. A ver si alguien me puede echar una mano en este asunto.
Tengo un sitio web, una biblitoteca y foro de phpBB 3.0.

Cuando cree el sitio utilice el foro como centro del sitio y la base de datos del mismo para gestionar el tema de los usuarios del sitio entero. Así un nuevo usuario tiene que registrarse en el foro para poder descargar libros.
Hace algunos días mude el sitio de servidor a uno mejor y actualice el foro a la ultima versión de phpBB 3.0. En la versión anterior (la primera versión de phpBB 3.0) las contraseñas eran encriptadas con md5 y no me dió mayor problema para hacer una validación de usuarios utilizando la misma base de datos del foro, pero ahora parece que cambiaron la forma de encriptación y no logro encontrar la vuelta para poder hacer dicha validación, que es en función de la cual los usuarios pueden utilizar el resto del sitio.

Quisiera saber si alguien se ha topado con este mismo problema o si tiene idea de que método de encriptación utiliza phpBB 3.0 (la ultima versión), para poder emularla en la validación de usuarios. Estuve intentando buscarle la vuelta en el mismo código de foro, pero la verdad no estoy a ese nivel de programación, ni por lejos. Si alguien me puede tirar un salva vidas estaré eternamente agradecido. Necesito solucionar esto urgentemente, ya que el sitio esta muy bien posicionado con algunas búsquedas pero debido a este problema esta totalmente inoperante.

Cree un usuario de prueba para ver como queda la encriptación a ver si alguien al verlo me sabe tirar alguna idea.

Usuario: pruebausuario
password: pruebausuario
password encriptado: $H$9O1igT1F9.4sRBpzCpTLDFp4h1qOD10

Desde ya muchas gracias por su ayuda.

Salu2
  #2 (permalink)  
Antiguo 17/02/2008, 13:58
Avatar de GatorV
$this->role('moderador');
 
Fecha de Ingreso: mayo-2006
Ubicación: /home/ams/
Mensajes: 38.567
Antigüedad: 14 años, 6 meses
Puntos: 2135
Re: Encriptación de contraseña en phpBB 3.0?

Tema trasladado a Aplicaciones Prefabricadas.

Por favor publica en los foros correctos.
  #3 (permalink)  
Antiguo 18/02/2008, 20:08
 
Fecha de Ingreso: marzo-2005
Mensajes: 70
Antigüedad: 15 años, 8 meses
Puntos: 0
Re: Encriptación de contraseña en phpBB 3.0?

Bueno, no entendí muy bien el problema que tienes (o qué hacías antes a la hora que el usuario ingresaba sus datos en el form) dado que tienes integrado tu sitio con tu phpBB. Muchos también tenemos intregrado nuestras págs con el foro para restringir secciones y todo eso únicamente utilizando la sesión del foro. Aún con el cambio de phpBB 2.0.X a 3.0.X, creo que nadie ha tenido problemas con esto de las contraseñas, ¿o sí? (y vaya que soy un novatazo con esto del PHP u____u)

Pero bue, en efecto, el equipo de phpBB se creo su propio hash para las contraseñas. Husmeando un poco encontré esto en la estructura...

functions.php línea 236
Código PHP:
/**
*
* @version Version 0.1 / $Id: functions.php,v 1.647 2007/12/10 18:35:28 kellanved Exp $
*
* Portable PHP password hashing framework.
*
* Written by Solar Designer <solar at openwall.com> in 2004-2006 and placed in
* the public domain.
*
* There's absolutely no warranty.
*
* The homepage URL for this framework is:
*
*    http://www.openwall.com/phpass/
*
* Please be sure to update the Version line if you edit this file in any way.
* It is suggested that you leave the main version number intact, but indicate
* your project name (after the slash) and add your own revision information.
*
* Please do not change the "private" password hashing method implemented in
* here, thereby making your hashes incompatible.  However, if you must, please
* change the hash type identifier (the "$P$") to something different.
*
* Obviously, since this code is in the public domain, the above are not
* requirements (there can be none), but merely suggestions.
*
*
* Hash the password
*/
function phpbb_hash($password)
{
    
$itoa64 './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';

    
$random_state unique_id();
    
$random '';
    
$count 6;

    if ((
$fh = @fopen('/dev/urandom''rb')))
    {
        
$random fread($fh$count);
        
fclose($fh);
    }

    if (
strlen($random) < $count)
    {
        
$random '';

        for (
$i 0$i $count$i += 16)
        {
            
$random_state md5(unique_id() . $random_state);
            
$random .= pack('H*'md5($random_state));
        }
        
$random substr($random0$count);
    }
    
    
$hash _hash_crypt_private($password_hash_gensalt_private($random$itoa64), $itoa64);

    if (
strlen($hash) == 34)
    {
        return 
$hash;
    }

    return 
md5($password);
}

/**
* Check for correct password
*/
function phpbb_check_hash($password$hash)
{
    
$itoa64 './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    if (
strlen($hash) == 34)
    {
        return (
_hash_crypt_private($password$hash$itoa64) === $hash) ? true false;
    }

    return (
md5($password) === $hash) ? true false;
}

/**
* Generate salt for hash generation
*/
function _hash_gensalt_private($input, &$itoa64$iteration_count_log2 6)
{
    if (
$iteration_count_log2 || $iteration_count_log2 31)
    {
        
$iteration_count_log2 8;
    }

    
$output '$H$';
    
$output .= $itoa64[min($iteration_count_log2 + ((PHP_VERSION >= 5) ? 3), 30)];
    
$output .= _hash_encode64($input6$itoa64);

    return 
$output;
}

/**
* Encode hash
*/
function _hash_encode64($input$count, &$itoa64)
{
    
$output '';
    
$i 0;

    do
    {
        
$value ord($input[$i++]);
        
$output .= $itoa64[$value 0x3f];

        if (
$i $count)
        {
            
$value |= ord($input[$i]) << 8;
        }

        
$output .= $itoa64[($value >> 6) & 0x3f];

        if (
$i++ >= $count)
        {
            break;
        }

        if (
$i $count)
        {
            
$value |= ord($input[$i]) << 16;
        }

        
$output .= $itoa64[($value >> 12) & 0x3f];
        
        if (
$i++ >= $count)
        {
            break;
        }

        
$output .= $itoa64[($value >> 18) & 0x3f];
    }
    while (
$i $count);

    return 
$output;
}

/**
* The crypt function/replacement
*/
function _hash_crypt_private($password$setting, &$itoa64)
{
    
$output '*';

    
// Check for correct hash
    
if (substr($setting03) != '$H$')
    {
        return 
$output;
    }

    
$count_log2 strpos($itoa64$setting[3]);

    if (
$count_log2 || $count_log2 30)
    {
        return 
$output;
    }

    
$count << $count_log2;
    
$salt substr($setting48);

    if (
strlen($salt) != 8)
    {
        return 
$output;
    }

    
/**
    * We're kind of forced to use MD5 here since it's the only
    * cryptographic primitive available in all versions of PHP
    * currently in use.  To implement our own low-level crypto
    * in PHP would result in much worse performance and
    * consequently in lower iteration counts and hashes that are
    * quicker to crack (by non-PHP code).
    */
    
if (PHP_VERSION >= 5)
    {
        
$hash md5($salt $passwordtrue);
        do
        {
            
$hash md5($hash $passwordtrue);
        }
        while (--
$count);
    }
    else
    {
        
$hash pack('H*'md5($salt $password));
        do
        {
            
$hash pack('H*'md5($hash $password));
        }
        while (--
$count);
    }

    
$output substr($setting012);
    
$output .= _hash_encode64($hash16$itoa64);

    return 
$output;

Espero te sirva.

Saludos.

  #4 (permalink)  
Antiguo 18/02/2008, 22:48
 
Fecha de Ingreso: junio-2007
Mensajes: 76
Antigüedad: 13 años, 4 meses
Puntos: 1
Re: Encriptación de contraseña en phpBB 3.0?

Hola Dark_Rulo.

En primer lugar quiero agradecerte el interés y tu respuesta.
Yo también estuve desglosando el código del phpBB y también llegue a encontrar lo que me muestras, pero fui un poco mas lejos. El hash que ellos están utilizando en 3.0 no lo crearon ellos sino que es un framework de la gente de http://www.openwall.com/phpass/ como tu mismo puedes ver en el codigo que me has facilitado.

Yo fui al sitio del autor de este framework que es gnu y lo baje. Es el código que tu pegas que esta dentro de phpBB 3.0 y algo mas. El paquete trae dos archivos uno que es el framework y otro archivo que sirve para provar el mismo que se llama test.

Intente modificar este test para aplicarlo en el login de mi sitio pero no obtuve buenos resultados. No me queda muy claro pero parece que se puede hacer algún pequeño cambio en la configuración y termina afectando el hash.

Dejo estos dos archivos a ver si tu o alguien mas logra encontrar la vuelta para modificar el test.php y usarlo para hacer un login.

Saludos y muchas gracias por la ayuda...

PD: pego en otro post el código aqui no me da el espacio...
  #5 (permalink)  
Antiguo 18/02/2008, 22:49
 
Fecha de Ingreso: junio-2007
Mensajes: 76
Antigüedad: 13 años, 4 meses
Puntos: 1
Re: Encriptación de contraseña en phpBB 3.0?

PasswordHash.php

Código PHP:
<?php
#
# Portable PHP password hashing framework.
#
# Version 0.1 / genuine.
#
# Written by Solar Designer <solar at openwall.com> in 2004-2006 and placed in
# the public domain.
#
# There's absolutely no warranty.
#
# The homepage URL for this framework is:
#
#    http://www.openwall.com/phpass/
#
# Please be sure to update the Version line if you edit this file in any way.
# It is suggested that you leave the main version number intact, but indicate
# your project name (after the slash) and add your own revision information.
#
# Please do not change the "private" password hashing method implemented in
# here, thereby making your hashes incompatible.  However, if you must, please
# change the hash type identifier (the "$P$") to something different.
#
# Obviously, since this code is in the public domain, the above are not
# requirements (there can be none), but merely suggestions.
#
class PasswordHash {
    var 
$itoa64;
    var 
$iteration_count_log2;
    var 
$portable_hashes;
    var 
$random_state;

    function 
PasswordHash($iteration_count_log2$portable_hashes)
    {
        
$this->itoa64 './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';

        if (
$iteration_count_log2 || $iteration_count_log2 31)
            
$iteration_count_log2 8;
        
$this->iteration_count_log2 $iteration_count_log2;

        
$this->portable_hashes $portable_hashes;

        
$this->random_state microtime() . getmypid();
    }

    function 
get_random_bytes($count)
    {
        
$output '';
        if ((
$fh = @fopen('/dev/urandom''rb'))) {
            
$output fread($fh$count);
            
fclose($fh);
        }

        if (
strlen($output) < $count) {
            
$output '';
            for (
$i 0$i $count$i += 16) {
                
$this->random_state =
                    
md5(microtime() . $this->random_state);
                
$output .=
                    
pack('H*'md5($this->random_state));
            }
            
$output substr($output0$count);
        }

        return 
$output;
    }

    function 
encode64($input$count)
    {
        
$output '';
        
$i 0;
        do {
            
$value ord($input[$i++]);
            
$output .= $this->itoa64[$value 0x3f];
            if (
$i $count)
                
$value |= ord($input[$i]) << 8;
            
$output .= $this->itoa64[($value >> 6) & 0x3f];
            if (
$i++ >= $count)
                break;
            if (
$i $count)
                
$value |= ord($input[$i]) << 16;
            
$output .= $this->itoa64[($value >> 12) & 0x3f];
            if (
$i++ >= $count)
                break;
            
$output .= $this->itoa64[($value >> 18) & 0x3f];
        } while (
$i $count);

        return 
$output;
    }

    function 
gensalt_private($input)
    {
        
$output '$P$';
        
$output .= $this->itoa64[min($this->iteration_count_log2 +
            ((
PHP_VERSION >= '5') ? 3), 30)];
        
$output .= $this->encode64($input6);

        return 
$output;
    }

    function 
crypt_private($password$setting)
    {
        
$output '*0';
        if (
substr($setting02) == $output)
            
$output '*1';

        if (
substr($setting03) != '$P$')
            return 
$output;

        
$count_log2 strpos($this->itoa64$setting[3]);
        if (
$count_log2 || $count_log2 30)
            return 
$output;

        
$count << $count_log2;

        
$salt substr($setting48);
        if (
strlen($salt) != 8)
            return 
$output;

        
# We're kind of forced to use MD5 here since it's the only
        # cryptographic primitive available in all versions of PHP
        # currently in use.  To implement our own low-level crypto
        # in PHP would result in much worse performance and
        # consequently in lower iteration counts and hashes that are
        # quicker to crack (by non-PHP code).
        
if (PHP_VERSION >= '5') {
            
$hash md5($salt $passwordTRUE);
            do {
                
$hash md5($hash $passwordTRUE);
            } while (--
$count);
        } else {
            
$hash pack('H*'md5($salt $password));
            do {
                
$hash pack('H*'md5($hash $password));
            } while (--
$count);
        }

        
$output substr($setting012);
        
$output .= $this->encode64($hash16);

        return 
$output;
    }

    function 
gensalt_extended($input)
    {
        
$count_log2 min($this->iteration_count_log2 824);
        
# This should be odd to not reveal weak DES keys, and the
        # maximum valid value is (2**24 - 1) which is odd anyway.
        
$count = (<< $count_log2) - 1;

        
$output '_';
        
$output .= $this->itoa64[$count 0x3f];
        
$output .= $this->itoa64[($count >> 6) & 0x3f];
        
$output .= $this->itoa64[($count >> 12) & 0x3f];
        
$output .= $this->itoa64[($count >> 18) & 0x3f];

        
$output .= $this->encode64($input3);

        return 
$output;
    }

    function 
gensalt_blowfish($input)
    {
        
# This one needs to use a different order of characters and a
        # different encoding scheme from the one in encode64() above.
        # We care because the last character in our encoded string will
        # only represent 2 bits.  While two known implementations of
        # bcrypt will happily accept and correct a salt string which
        # has the 4 unused bits set to non-zero, we do not want to take
        # chances and we also do not want to waste an additional byte
        # of entropy.
        
$itoa64 './ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

        
$output '$2a$';
        
$output .= chr(ord('0') + $this->iteration_count_log2 10);
        
$output .= chr(ord('0') + $this->iteration_count_log2 10);
        
$output .= '$';

        
$i 0;
        do {
            
$c1 ord($input[$i++]);
            
$output .= $itoa64[$c1 >> 2];
            
$c1 = ($c1 0x03) << 4;
            if (
$i >= 16) {
                
$output .= $itoa64[$c1];
                break;
            }

            
$c2 ord($input[$i++]);
            
$c1 |= $c2 >> 4;
            
$output .= $itoa64[$c1];
            
$c1 = ($c2 0x0f) << 2;

            
$c2 ord($input[$i++]);
            
$c1 |= $c2 >> 6;
            
$output .= $itoa64[$c1];
            
$output .= $itoa64[$c2 0x3f];
        } while (
1);

        return 
$output;
    }

    function 
HashPassword($password)
    {
        
$random '';

        if (
CRYPT_BLOWFISH == && !$this->portable_hashes) {
            
$random $this->get_random_bytes(16);
            
$hash =
                
crypt($password$this->gensalt_blowfish($random));
            if (
strlen($hash) == 60)
                return 
$hash;
        }

        if (
CRYPT_EXT_DES == && !$this->portable_hashes) {
            if (
strlen($random) < 3)
                
$random $this->get_random_bytes(3);
            
$hash =
                
crypt($password$this->gensalt_extended($random));
            if (
strlen($hash) == 20)
                return 
$hash;
        }

        if (
strlen($random) < 6)
            
$random $this->get_random_bytes(6);
        
$hash =
            
$this->crypt_private($password,
            
$this->gensalt_private($random));
        if (
strlen($hash) == 34)
            return 
$hash;

        
# Returning '*' on error is safe here, but would _not_ be safe
        # in a crypt(3)-like function used _both_ for generating new
        # hashes and for validating passwords against existing hashes.
        
return '*';
    }

    function 
CheckPassword($password$stored_hash)
    {
        
$hash $this->crypt_private($password$stored_hash);
        if (
$hash[0] == '*')
            
$hash crypt($password$stored_hash);

        return 
$hash == $stored_hash;
    }
}

?>

test.php

Código PHP:
<?php
#
# This is a test program for the portable PHP password hashing framework.
#
# Written by Solar Designer and placed in the public domain.
# See PasswordHash.php for more information.
#

require "PasswordHash.php";

header("Content-type: text/plain");

$ok 0;

# Try to use stronger but system-specific hashes, with a possible fallback to
# the weaker portable hashes.
$t_hasher = new PasswordHash(8FALSE);

$correct "test12345";
$hash $t_hasher->HashPassword($correct);

print 
"Hash: " $hash "\n";

$check $t_hasher->CheckPassword($correct$hash);
if (
$check$ok++;
print 
"Check correct: '" $check "' (should be '1')\n";

$wrong "test12346";
$check $t_hasher->CheckPassword($wrong$hash);
if (!
$check$ok++;
print 
"Check wrong: '" $check "' (should be '0' or '')\n";

unset(
$t_hasher);

# Force the use of weaker portable hashes.
$t_hasher = new PasswordHash(8TRUE);

$hash $t_hasher->HashPassword($correct);

print 
"Hash: " $hash "\n";

$check $t_hasher->CheckPassword($correct$hash);
if (
$check$ok++;
print 
"Check correct: '" $check "' (should be '1')\n";

$check $t_hasher->CheckPassword($wrong$hash);
if (!
$check$ok++;
print 
"Check wrong: '" $check "' (should be '0' or '')\n";

# A correct portable hash for "test12345".
# Please note the use of single quotes to ensure that the dollar signs will
# be interpreted literally.  Of course, a real application making use of the
# framework won't store password hashes within a PHP source file anyway.
# We only do this for testing.
$hash '$P$9IQRaTwmfeRo7ud9Fh4E2PdI0S3r.L0';

print 
"Hash: " $hash "\n";

$check $t_hasher->CheckPassword($correct$hash);
if (
$check$ok++;
print 
"Check correct: '" $check "' (should be '1')\n";

$check $t_hasher->CheckPassword($wrong$hash);
if (!
$check$ok++;
print 
"Check wrong: '" $check "' (should be '0' or '')\n";

if (
$ok == 6)
    print 
"All tests have PASSED\n";
else
    print 
"Some tests have FAILED\n";

?>
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Tema Cerrado




La zona horaria es GMT -6. Ahora son las 02:07.