Una parte crucial de la práctica de desarrollo de PHP está siempre
teniendo en cuenta que la seguridad no es algo que simplemente puede comprar
fuera de la plataforma en su tienda de comestibles local. Garantizar la
seguridad de sus aplicaciones web es un proceso, que con el tiempo, necesita
ser constantemente evaluado, monitoreado y endurecido.
¿Cómo generar valores aleatorios con PHP?
La generación de contraseñas aleatorias
Salazón contraseñas y autenticación del usuario
Ofuscación en PHP, una visión general
Criptografía en PHP y de las aplicaciones informáticas
<? Php
rand (int $
min , int $ max );
mt_rand (int
$ min , int $ max );
str_shuffle ( $ cadena );
uniqid ( $ prefix , mas_entropia =);
?>
Las dos funciones rand () y mt_rand () son probablemente las
funciones más ampliamente utilizado para generar un conjunto de números
aleatorios en PHP. La función rand () ; es un generador de más edad, y se está
cayendo en desuso debido a mt_rand(),
lo que es más rápido, más fiable y puede manejar un mayor valor entero máximo
en algunas plataformas. La función str_shuffle () hace exactamente lo que se
esperaría que, se baraja una cadena que se le pasa.
Generar contraseñas aleatorias
La generación de contraseñas aleatorias es muy útil en los registros de
usuarios, o cuando un usuario realiza una solicitud debido a que han olvidado
sus contraseñas . Esto garantiza una contraseña segura al principio de una
experiencia de los usuarios en su sitio web, o puede reducir las líneas de
código cuando un usuario tiene que acceder de nuevo.
Ejemplo1
<?php
//A simple function which will
output a random password
function
randompassword($count){
$pass =
str_shuffle('abcefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890@#%$*');
return
substr($pass,3,$count);//returns the password
}
?>
Ejemplo2
<?php
//Another example to create a
random password
function anorandpass($count) {
$m_rand = mt_rand(); //generate a random integer
$u_id = uniqid("MNO!@#$%^&*=+XYZ", TRUE);//create a unique
identifier with some extra prefix and extra entropy
$combine = $m_rand . $u_id;// Combine the variables to form a
string
$new = str_shuffle($combine);//shuffle our string
return substr($new, 2, $count);//return the password
}
print anorandpass(8);
?>
En comparación, el
ejemplo se toma una cadena estática y lo mezcla hasta la devuelve, el ejemplo
de dos añade más sabor dinámico (mmm sabroso). En el ejemplo dos la cadena que
se está arrastrando los pies ya no es estática, sino que cambia con cada generación.
Salazón de
contraseñas para mayor seguridad.
Salazón contraseñas es una forma eficaz de aumentar la
seguridad de los usuarios de las cuentas, incluso si un atacante obtiene acceso
a su base de datos, si se hace bien. Se puede argumentar que, con el acceso a
la sal, un atacante puede obtener sus credenciales. Aunque esto es cierto, la
aplicación de algunas técnicas de aleatorización para el almacenamiento de
contraseñas hará que el proceso extremadamente difícil, especialmente si el
almacenamiento de la información del usuario y el contenido se dividen en bases
de datos separadas.
¿Porqué?
Para que una aplicación web para utilizar una sal de
una contraseña, la aplicación tiene que almacenar en algún lugar. No es
recomendable usar la misma sal a través de una base de datos completa de las
contraseñas, sino para generar una sal única por usuario. Generación de una sal
de una base de datos completa en realidad disminuye la seguridad de la
aplicación web en el sentido de que si un atacante logra resolverlo, es el
conjunto del dispositivo está roto, o si se pierde, hace que la base de datos
inútiles. La creación de un sistema completo de registro del miembro hecho y
derecho con todas las campanas y silbatos está fuera del alcance de este
tutorial, sin embargo, será la creación de un sistema simple de usar un
ejemplo. Echemos un vistazo a la generación de una sal y la aplicación de algunas
técnicas de asignación al azar:
Empezamos
Diseñamos nuestra base de datos
CREATE
TABLE IF NOT EXISTS `users` (
`usr_id` int(11) NOT NULL AUTO_INCREMENT,
`usr_name` varchar(24) NOT NULL,
`usr_pass` varchar(32) NOT NULL,
`usr_email` varchar(255) NOT NULL,
`usr_salt` varchar(255) NOT NULL,
PRIMARY KEY (`usr_id`)
)
ENGINE=MyISAM DEFAULT CHARSET=latin1 ;
Creamos
el config.php
<?php
/*db_config.php*/
//database
configuration
$db_host
="localhost" ; //will likely stay the same
$db_name =
"thedbname"; //the name of the database table
$db_usr = "username";
//your database username
$db_pass =
"password";//your database password
//Establish a connection
with MySQL and select the database to use
mysql_connect($db_host,
$db_usr, $db_pass) or die("MySQL Error: " . mysql_error());
mysql_select_db($db_name)
or die("MySQL Error: " . mysql_error());
?>
Registro.php
<?php
/*registration.php*/
//require our db_config.php
file
require
('db_config.php');
//Check to see if the form
has been submitted
if(!empty($_POST['username']) && !empty($_POST['email']) &&
!empty($_POST['password'])) {
//Escape our posted inputs
$username =
mysql_real_escape_string($_POST['username']);
$email =
mysql_real_escape_string($_POST['email']);
$password =
mysql_real_escape_string($_POST['password']);
//generate a strong unique salt
$salt_gen = uniqid(mt_rand());
//Combine email, the password and the salt
together
$combine = $email . $password . $salt_gen;
//md5 hash the combined password * Note:
md5 is only used in this scenario as an example
$newpassword = md5($combine);
//insert the values into the database
$registerquery = mysql_query("INSERT
INTO users (usr_name, usr_pass, usr_email,
usr_salt) VALUES ('".$username."',
'".$newpassword."', '".$email."',
'".$salt_gen."')") or die("MySQL Error:
".mysql_error());
//let the user know of success or
failure
if ($registerquery) {
echo '<h1>Success</h1>';
} else {
echo
'<h1>Failure</h1>';
}
}
?>
Vamos a repasar el código PHP. Para simplificar las
cosas debemos incluir nuestro archivo de configuración de base de datos.
Siguiente PHP comprueba para ver si el código HTML formulario ha sido enviado
por comprobar si los $ _POST variables no están vacías. Si no lo están,
entonces el script procede a escapar de los datos del formulario enviado desde
el usuario, su preparación para ser insertado en la base de datos. A
continuación, generar una sal simple usando uniqid () y mt_rand () y
almacenarla en la variable $ salt_gen . Para salar nuestra contraseña
combinamos la contraseña $, entonces la sal. El siguiente paso, una manera de
hashing las variables combinadas con md5.
si un atacante obtiene acceso a mi base de datos de
alguna manera, y la sal, la única manera de que el atacante va a saber a
ciencia cierta que la dirección de correo electrónico se utiliza en el hash de
la contraseña es si tienen acceso a el código fuente. Cómo aleatorio y único es
una dirección de correo electrónico?
Para rematar el resto del código PHP off insertamos
nuestras variables en la tabla de base de datos dentro de sus respectivos
campos, y dar al usuario una retroalimentación sobre el éxito o el fracaso.
Ahora el resto del archivo de registro, el código HTML.
Rematamos el código
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<form
action="" method="post">
<label for="username">Enter
a Username</label>
<input type="text"
name="username" /><br />
<label for="email">Enter
your Email</label>
<input type="text"
name="email" /><br />
<label for="password">Enter
a Password</label>
<input type="password"
name="password" /><br />
<input type="submit"
name="submit" value="Submit" />
</form>
</body>
</html>
3. Autenticación del usuario
Así que ahora tenemos
un sencillo formulario de registro, que inserta un usuario en la base de datos
junto con sus contraseñas con sal. Vamos a crear una página de inicio de sesión
que nos obliga a recuperar información de la base de datos y la autenticación
del usuario. En primer lugar el PHP:
<?php
/*login.php*/
//require our db_config.php
file
require ('db_config.php');
//Check to see if the form has been
submitted
if(!empty($_POST['username']) && !empty($_POST['password'])) {
//Escape our posted inputs
$username = mysql_real_escape_string($_POST['username']);
$password = mysql_real_escape_string($_POST['password']);
//Grab the row associated with the username from the form
$grab_row = mysql_query("SELECT * FROM users WHERE usr_name =
'".$username."'") or die ("MySQL Error:
".mysql_error());
//If only one row was retrieved
if (mysql_num_rows($grab_row) == 1) {
//create an array from the row
fields
$row =
mysql_fetch_array($grab_row);
//store the users salt in a var
$salt = $row['usr_salt'];
//store the users email in a var
$email = $row['usr_email'];
//recombine the variables email,
password, and the salt
$combine = $email . $password .
$salt;
//re-hash the combined variables
Note:md5 is only used in this scenario as an example
$auth_pass = md5($combine);
//check the database again for the row
associated with the username and the rehashed password
$checklogin = mysql_query("SELECT * FROM
users WHERE usr_name = '".$username."' AND usr_pass =
'".$auth_pass."'") or die("MySQL Error:
".mysql_error());
//if only one row is retrieved output
success or failure to the user
if(mysql_num_rows($checklogin) == 1)
{
echo '<h1>Yippie, we are
authenticated!</h1>';
} else {
echo '<h1>Oh no, we are not
authenticated!</h1>';
}
} else {
echo '<h1>Oh no, we are not in
the database!</h1>';
}
}
?>
Algunos consejos
ofuscación
->Siempre, siempre, tenga una versión limpia de la
fuente para usted.
Cuanto más aleatoria la técnica, mejor.
->Eliminar todos los espacios en blanco, donde no se
necesita.
->Codificar caracteres impresos / ed caracteres echo 'y
espacios (por ejemplo, las citas, los espacios delgados, apostropes, hypens)
->Cuanto más complejo es el código, mejor.
->No tenga en cuenta la estructura a menos que sea
perjudicial para el funcionamiento del código (antiguos lugares de variables
antes de que sean llamados)
->No utilice nombres de variables distinguibles,
espacios de nombres o nombres de clase.
->Cuanto menos código vuelve a utilizar, mejor no creo que sea infalible.
Artículos relacionados
0 comentarios:
Publicar un comentario