Red de conocimiento informático - Conocimiento del nombre de dominio - Cómo implementar un blog personal de WordPress para que cuando otros ingresen e ingresen mi nombre de dominio, se requiera la verificación de la contraseña antes de que puedan ingresar.

Cómo implementar un blog personal de WordPress para que cuando otros ingresen e ingresen mi nombre de dominio, se requiera la verificación de la contraseña antes de que puedan ingresar.

1. Al estudiar WordPress, los métodos de generación de contraseñas y verificación de contraseñas de inicio de sesión de WordPress son muy importantes.

Las contraseñas de WordPress se han convertido en el objetivo principal de la integración. Cómo conquistar la integración requiere comprender el algoritmo de contraseñas de WordPress.

La contraseña de usuario del sistema WordPress se almacena en el campo user_pass de la tabla de datos wp_users. La contraseña se genera a través de la clase de marco de hash de contraseña PHP portátil. La forma de la contraseña es aleatoria e irreversible. Se utiliza la misma contraseña de texto claro en diferentes momentos, el texto cifrado generado también es diferente, lo cual es relativamente más seguro.

Dos. Método de generación de contraseña

> Genere aleatoriamente un salt y agregue el salt y la contraseña

> Realice el recuento md5 y luego agréguelo al valor hash de encode64

> Finalmente, obtenemos una contraseña que comienza con $P$. El resultado de esta contraseña es diferente cada vez

El siguiente es el código generado al llamar a la contraseña en wordpress

[php]. ¿ver copia simple imprimir?

$contraseña = 'abc'

global $wp_hasher

if (vacío); ($ wp_hasher) ) {

require_once( './wp-includes/class-phpass.php');

$wp_hasher = nueva ContraseñaHash(8, VERDADERO

}

echo $wp_hasher->HashPassword($contraseña); >

Tres.

Generación de contraseñas de WordPress y verificación de inicio de sesión

La ubicación en WordPress es \wp-includes\class-phpass.php

El siguiente es el código para generar contraseñas en WordPress Ejecútelo directamente en. ver el proceso de generación y verificación de contraseña

[php] ¿ver copia simple imprimir?

class PasswordHash {

var $itoa64;

p>

var $iteration_count_log2;

var $portable_hashes

var $random_state

función ContraseñaHash; ($iteration_count_log2, $portable_hashes)

{

$this->itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';

if ($iteration_count_log2 < 4 || $ iteration_count_log2 > 31)

$iteration_count_log2 = 8;

$this->iteration_count_log2 = $iteration_count_log2

$this->portable_hashes = $portable_hashes

$this->random_state = microtime() . uniqid(rand(), TRUE); // eliminado getmypid() por razones de compatibilidad

}

función get_random_bytes ($count)

{

$salida = '';

if ( @is_readable('/dev/urandom') &&

($fh = @fopen(' /dev/urandom', 'rb'))) {

$salida = fread($fh, $count); ($fh);

}

if (strlen($salida) < $cuenta) {

$salida = ''; p> for ($i = 0; $ i < $count; $i += 16) {

$this->random_state =

md5(microtime() . $this ->estado_aleatorio);

$salida .=

pack('H*', md5($this->random_state));

}

$salida = substr($salida). , 0, $cuenta);

}

devuelve $salida;

}

función codificar64($entrada, $cuenta)

{

$salida = '';

$i = 0

hacer {

$; valor = ord($entrada[$i++]);

$salida .= $this->itoa64[$valor & 0x3f];

if ($i < $cuenta)

$valor |= ord($entrada[$i]) << 8

$salida .= $this->itoa64[($valor >> 6) & 0x3f ];

if ($i++ >= $count)

descanso

if ($i < $count)

$; valor |= ord($entrada[$i]) << 16

$salida .= $this->itoa64[($valor >> 12) & 0x3f]; > if ($i++ >= $cuenta)

descanso

$salida .= $this->itoa64[($valor >> 18) & 0x3f]; >

} while ($i < $count);

return $salida

}

función gensalt_private($entrada)

{

$salida = '$PXXXXX

$salida .= $this->itoa64[min($this->iteration_count_log2 +

((PHP_VERSION >= '5') ? 5 : 3), 30)]

$salida .= $this->encode64($entrada, 6

); $ salida

ut;

}

función crypt_private($contraseña, $configuración)

{

$salida = '*0'; /p>

if (substr($configuración, 0, 2) == $salida)

$salida = '*1'

$id = substr($ configuración, 0, 3);

# Usamos "$P{1}quot;, phpBB3 usa "$H{1}quot para lo mismo

if ($ id != '$PXXXXX && $id != '$HXXXXX)

return $salida

$count_log2 = strpos($this->itoa64, $setting[3])

if ($count_log2 < 7 || $count_log2 > 30)

devuelve $salida

$count = 1 << $count_log2

p>

$sal = substr($configuración, 4, 8

if (strlen($sal) != 8)

return $ salida;

# Estamos un poco obligados a usar MD5 aquí ya que es la única

# primitiva criptográfica disponible en todas las versiones de PHP

# actualmente. utilizar implementar nuestra propia criptografía de bajo nivel

# en PHP daría como resultado un rendimiento mucho peor y

# en consecuencia, menores recuentos de iteraciones y hashes

# más rápido de descifrar (por código que no sea PHP

if (PHP_VERSION >= '5') {

$hash = md5($salt . $contraseña, TRUE) ;

hacer {

$hash = md5($hash . $contraseña, TRUE

} while (--$count); >

} else {

$hash = pack('H*', md5

($sal . $contraseña));

do {

$hash = pack('H*', md5($hash . $contraseña)); p> } while (--$count);

}

$salida = substr($configuración, 0, 12);

$salida .= $this->encode64($hash, 16);

devolver $salida

}

función gensalt_extended($entrada)

{

$count_log2 = min($this->iteration_count_log2 + 8,

# Esto debería ser extraño para no revelar claves DES débiles y

# el valor máximo válido es (2**24 - 1), que de todos modos es impar

$count = (1 << $count_log2) - 1

$output. = '_';

$salida .= $this->itoa64[$count & 0x3f]

$salida .= $this->itoa64[($count >> 6) & 0x3f];

$salida .= $this->itoa64[($count >> 12) & 0x3f]

$salida .= $this->itoa64; [($count >> 18) & 0x3f];

$salida .= $this->encode64($entrada, 3

return $salida

);

}

function gensalt_blowfish($input)

{

# Este necesita usar un orden diferente de caracteres y un

# esquema de codificación diferente al de encode64() anterior

# Nos importa porque el último carácter de nuestra cadena codificada

# solo representará 2 bits. implementaciones de

# bcrypt

Aceptar felizmente y corregir una cadena de sal que

# tiene los 4 bits no utilizados establecidos en un valor distinto de cero, no queremos correr

# riesgos y tampoco queremos desperdiciar un byte adicional

# de entropía

$itoa64 = './ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'

$output = '$2aXXXXX

$salida .= chr(ord('0') + $this->iteration_count_log2 / 10);

$salida .= chr(ord('0') + $this->iteration_count_log2 % 10 ;

$salida .= 'XXXXX

$i = 0

hacer {

$c1 = ord($ entrada[$i++]);

$salida .= $itoa64[$c1 >> 2]

$c1 = ($c1 & 0x03) << 4; p>

p>

if ($i >= 16) {

$salida .= $itoa64[$c1];

descanso

}

$c2 = ord($entrada[$i++]);

$c1 |= $c2 >> 4; .= $itoa64[ $c1];

$c1 = ($c2 & 0x0f) << 2

$c2 = ord($entrada[$i++]); /p>

$c1 |= $c2 >> 6;

$salida .= $itoa64[$c1]

$salida .= $itoa64[$c2; & 0x3f];

} mientras (1);

devuelve $salida

}

función HashPassword($contraseña)

{

$aleatorio = '';

si (CRYPT_BLOWFISH == 1 && !$ésimo

es->portable_hashes) {

$random = $this->get_random_bytes(16);

$hash =

crypt($contraseña, $this- >gensalt_blowfish($random));

if (strlen($hash) == 60)

return $hash

}

if (CRYPT_EXT_DES == 1 && !$this->portable_hashes) {

if (strlen($random) < 3)

$random = $this->get_random_bytes( 3);

$hash =

cripta($contraseña, $this->gensalt_extended($random)); == 20)

return $hash

}

if (strlen($random) < 6)

$random = $this->get_random_bytes(6);

$hash =

$this->crypt_private($contraseña,

$this->gensalt_private($random) ));

if (strlen($hash) == 34)

return $hash;

# Devolver '*' en caso de error es seguro aquí, pero _no_ sería seguro

# en una función similar a crypt(3) usada _tanto_ para generar nuevos

# hashes como para validar contraseñas contra hashes existentes

return '*';

}

función CheckPassword($contraseña, $stored_hash)

{

$hash = $this ->crypt_private($contraseña, $stored_hash

if ($hash[0] == '*')

$hash

= cripta($contraseña, $stored_hash);

return $hash == $stored_hash

}

}

// Contraseña original

$passwordValue = "123456";

//Generar contraseña

$wp_hasher = new PasswordHash(8, TRUE); p>$sigPassword = $wp_hasher->HashPassword($passwordValue);

echo "La contraseña generada es:".$sigPassword

echo "\n"; >

//Verificar contraseña

$data = $wp_hasher->CheckPassword($passwordValue,$sigPassword

if($data){

echo 'La contraseña es correcta';

}else{

echo 'La contraseña es incorrecta'

} >

Esto es un ejemplo de wordpres de generación de contraseña y verificación de inicio de sesión, donde HashPassword es la contraseña generada y CheckPassword es la contraseña de verificación

itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz' es la cadena básica para generar salt mencionada anteriormente.

Nota: Debido a las restricciones de caracteres especiales en el complemento de visualización de código csdn. Reemplace XXXXX en el código anterior con $'. Tenga en cuenta que hay comillas simples. Hay 5 lugares para *** en el código

.