Autenticación Segura con Hashes y Clave Secreta en PHP

Clase 12 de 19 • Curso de API REST con PHP

Resumen

Para esta autenticación necesitamos 3 elementos:

Función Hash: Difícil de romper, que sea conocida por el cliente y servidor.
Clave secreta: Solamente la pueden saber el cliente y el servidor, será utilizada para corroborar el hash.
UID: El id del usuario, será utilizado dentro de la función hash junto con la clave secreta y un timestamp.

Es mucho más segura que la autenticación vía HTTP, por ello la información que se envía a través de este método no es muy sensible.

Franklin Rosas

student•

¿Que es un HASH? Una función criptográfica hash- usualmente conocida como “hash”- es un algoritmo matemático de seguridad que transforma cualquier bloque arbitrario de datos en una nueva serie de caracteres, con la característica particular de siempre poseer una longitud fija. Esto quiere decir que, sin importar la longitud de los datos de entrada, la longitud del valor hash de salida siempre es la misma.

Para más información sobre el tema puedes visitar este blog de kaspersky

Mariano Gastón Paduani

student•

Gracias!

Walter Jesus Santiago Gonzalez

student•

Script auxiliar generate_hash.php

<?php

$time = time();
echo "Time: $time".PHP_EOL."Hash: ".sha1($argv[1].$time.'Sh!! No se lo cuentes a nadie!');

Pablo Inaipil

student•

Le falto esta colita del código: ........'Sh!! No se lo cuentes a nadie!').PHP_EOL; saludos!

Paul Cortes

student•

Autenticación vía HMAC Para esta autenticación necesitamos 3 elementos:

Función Hash: Difícil de romper, que sea conocida por el cliente y servidor
Clave secreta: Solamente la pueden saber el cliente y el servidor, será utilizada para corroborar el hash.
UID: El id del usuario, será utilizado dentro de la función hash junto con la clave secreta y un timestamp.

Es mucho más segura que la autenticación vía HTTP, por ello la información que se envía a través de este método no es muy sensible.

Luis Abdel Rangel Castro

student•

<?php

/*
-- Autenticacion via HTTP
$user = array_key_exists('PHP_AUTH_USER',$_SERVER) ? $_SERVER['PHP_AUTH_USER'] : '';
$pwd = array_key_exists('PHP_AUTH_PW',$_SERVER) ? $_SERVER['PHP_AUTH_PW'] : '';

if ($user !== 'mauro' || $pwd !== '1234') {
	die;
}
*/

// Autenticacion via HMAC
if (!array_key_exists('HTTP_X_HASH',$_SERVER) || !array_key_exists('HTTP_X_TIMESTAMP',$_SERVER) || !array_key_exists('HTTP_X_UID',$_SERVER)) {
	die;
}

list($hash,$uid,$timestamp) = [
	$_SERVER['HTTP_X_HASH'],
	$_SERVER['HTTP_X_UID'],
	$_SERVER['HTTP_X_TIMESTAMP']
];

$secret = 'Sh!! No se lo cuentes a nadie!';

$newHash = sha1($uid.$timestamp.$secret);

if ($newHash !== $hash) {
	die;
}

// Definimos los recursos disponibles
$allowedResourceTypes = [
	'books',
	'authors',
	'genres',
];

// Validamos que el recurso este disponible
$resourceType = $_GET['resource_type'];

if (!in_array($resourceType,$allowedResourceTypes)) {
	die;
}

// Defino los recursos
$books = [
    1 => [
        'titulo' => 'Lo que el viento se llevo',
        'id_autor' => 2,
        'id_genero' => 2,
    ],
    2 => [
        'titulo' => 'La Iliada',
        'id_autor' => 1,
        'id_genero' => 1,
    ],
    3 => [
        'titulo' => 'La Odisea',
        'id_autor' => 1,
        'id_genero' => 1,
    ],
];

// Se indica al cliente que lo que recibirá es un json
header('Content-Type: application/json');

// Levantamos el id del recurso buscado
// utilizando un operador ternario
$resourceId = array_key_exists('resource_id', $_GET) ? $_GET['resource_id'] : '';

// Generamos la respuesta asumiendo que el pedido es correcto
switch (strtoupper($_SERVER['REQUEST_METHOD'])) {
	case 'GET':
		if (empty($resourceId)) {
			echo json_encode($books);
		} else {
			if (array_key_exists($resourceId,$books)) {
				echo json_encode($books[$resourceId]);
			}
		}
		break;

	case 'POST':
		$json = file_get_contents('php://input');
		$books[] = json_decode($json,true);
		//echo array_keys($books)[count($books)-1];
		end($books);         // move the internal pointer to the end of the array
		$key = key($books);  // fetches the key of the element pointed to by the internal pointer
		echo json_encode($books[$key]);
 		break;

	case 'PUT':
		// Validamos que el recurso buscado exista
		if (!empty($resourceId) && array_key_exists($resourceId,$books)) {
			// Tomamos la entrada curda
			$json = file_get_contents('php://input');

			// Tansformamos el json recibido a un nuevo elemento
			$books[$resourceId] = json_decode($json,true);

			echo json_encode($books[$resourceId]);
		}
		break;

	case 'DELETE':
		// Validamos que el recurso buscado exista
		if (!empty($resourceId) && array_key_exists($resourceId,$books)) {
			unset($books[$resourceId]);
			echo json_encode($books);
		}
		break;
}



// Inicio el servidor en la terminal 1
// php -S localhost:8000 server.php

// Terminal 2 ejecutar 
// curl http://localhost:8000 -v
// curl http://localhost:8000/\?resource_type\=books
// curl http://localhost:8000/\?resource_type\=books | jq

Jimmy Buriticá Londoño

student•

Gracias

Enrique Garcia Stave

student•

Apuntes: Esta autenticación es un poco más segura. Es un Código de autorización basado en hash de mensajes. Un hash es una funcionalidad que encripta un texto. Se basa en un hash (encriptada) que se conoce por el cliente o servidor y luego un token de verificación conocido por el cliente y servidor (solamente) y el UID (User ID), que correspondería a la ID del usuario que será usada en la función hash junto con la contraseña secreta y un timestamp. El procedimiento es parecido al anterior, a diferencia que se tomaran 3 variables globales de servidor (HTTP_X_HASH, HTTP_X_TIMESTAMP, HTTP_X_UID).

curl http://localhost:80/books -H "X-HASH: hashGenerado" -H "X-UID: tuIdUsuario" -H "X-TIMESTAMP: hashGeneradoDelTimeStamp"

Mariano Gastón Paduani

student•

Gracias!

Royer Guerrero Pinilla

student•

Version en python con flask Cuando lo haces en otra tecnología con otro lenguaje en realidad aprendes como funciona porque no solo vez y sigues el código sino que piensas, armas la lógica de auhtificacion usando otras librerías o paquetes

Carlos Nassif Trejo Garcia

student•

Agregue un poco de comentarios :)

def auth_required(func):
    def wrapper(self):
        try:
            hash_api = request.headers.get('X-HASH') # Get the headers
            hash_client = hmac.new(key=SECRET.encode(), digestmod=hashlib.sha1) # Set the hash algorithm
            hash_client.update(request.headers.get('X-UID').encode()) # Set the UID
            hash_client.update(request.headers.get('X-TIMESTAMP').encode()) # Set the TIMESTAMP (UNIX)
        
            # If hashes are the same, then give access to the function
            if hash_api == hash_client.hexdigest():
                return func(self)

        # An error occured trying to resolve the values necesarry for the hash
        except:
            return make_response('Please authenticate by HMAC on X headers!', 401, {'WWW-Autencticate': 'Basic reaml="Login Required"'})
        
        # Hashes are not a mach, return an error
        return make_response('Could not verify your login!', 401, {'WWW-Autencticate': 'Basic reaml="Login Required"'})

    return wrapper

Lucas Alvarez

student•

++Mi intento en javascript++ Actualizando el middleware que hice en la clase anterior, para permitir HTTP o HMAC dependiendo cual se envíe

// Middleware de autenticación
const bookAuthenticator = (req, res, next) => {  
  // Obtiene la autenticación como "username:password" 
  // Y lo convierte en un array como ["username", "password"]
  let authorization = [];

  // Verificamos si se envian headers de autenticación HTTP
  if(req.headers.authorization) {
    // req.headers.authorization es encodeado en base64, tal como: "Basic bHVjbmVvbmN0OjEyMzQ="
    // Con un Buffer lo decodeamos: Buffer.from('string','base64')
    authorization = Buffer
      // Separamos en dos arreglos, para usar solo el string encodeado
      // ["Basic", "bHVjbmVvbmN0OjEyMzQ="]
      .from(req.headers.authorization.split(" ")[1], 'base64')
      // Lo transformamos en utf-8
      // "lucneonct:1234"
      .toString('utf-8')
      // Lo separamos por el ":" en un array
      // ["lucneonct", "1234"]
      .split(':');
  } 
  // Verificamos si se envian headers de autenticación HMAC
  else if(req.headers['x-hash']) {
    // Recibe los parametros enviados en req.headers
    // Si no hay se lo deja en blanco
    const hash = req.headers['x-hash'] || '';
    const uid = req.headers['x-uid'] || '';
    const timestamp = req.headers['x-timestamp'] || '';

    // Creamos nuestro secret
    const secret = 'Sh!! No se lo cuentes a nadie!';

    // Usamos el paquete de crypto que viene con NodeJS para crear el SHA1
    const hmac = crypto.createHmac('sha1', secret);
    // Pasamos nuestro UID y TIMESTAMP al método update
    hmac.update( uid + timestamp );

    // Comparamos que el hash enviado y el creado sean iguales
    // Usamos hmac.digest('hex') para que nos muestre el hash en hexadecimal
    if(hash === hmac.digest('hex')) {
      // Rellenamos nuestro arreglo de autorización para pasar la validación posterior
      authorization = ['Lucneonct', '1234'];
    }
  }

  // Obtiene username del primer indice del arreglo y la contraseña del segundo
  const authUser = authorization[0];
  const authPassword = authorization[1];

  // Verificamos si los datos no coinciden con nuestro usuario hardcodeado
  if( authUser !== "Lucneonct" && authPassword !== "1234") {
    // Rompe la cadena y retorna un 403 Forbidden
    return res.status(403).json({ status: 'Forbidden: missing or invalid auth' });
  }

  next()
}

Para hacer la solicitud, el hash lo generé en https://www.freeformatter.com/hmac-generator.html. usando id = 1+timestamp = 123456789 Quedaría 1123456789 y el secret Sh!! No se lo cuentes a nadie! Usando curl con HMAC sería de la siguiente forma:

curl localhost:5000/?resource_type=books -H "X-HASH: 82db2fbfb7f3c476dca3d750d43810d22d38e8ea" -H "X-UID: 1" -H "X-TIMESTAMP: 123456789" | jq

Y si lo pongo de forma incorrecta, por ejemplo, restando 1 al timestamp:

curl localhost:5000/?resource_type=books -H "X-HASH: 82db2fbfb7f3c476dca3d750d43810d22d38e8ea" -H "X-UID: 1" -H "X-TIMESTAMP: 123456788" | jq

Y también se podría usar curl con HTTP

curl lucneonct:1234@localhost:5000/?resource_type=books | jq

IRIDIAN GUADALUPE CARRERA MONDRAGÓN

student•

Me funciono con comillas dobles en windows:

curl http://localhost:8000/books -H "X-HASH: ************" -H "X-UID: 1" -H "X-TIMESTAMP: *******"

Alessandro Staiano

student•

A mi también me funciono asi, gracias :)

Cristhian Alexis Castro Correa

student•

Muchas gracias, era lo que me faltaba

Carlos Eduardo Gomez García

teacher•

Vale, prácticamente HMAC lo que hace es mandar algunos datos encriptados con base en una "contraseña" y simplemente el servidor usa la misma contraseña para encriptar esos mismos datos y ver si da el mismo hash para entonces otorgar la autenticación

María Sierra

student•

Autenticación vía HMAC

El método de autenticación HMAC o Hash-based message authentication code (Código de autenticación de mensajes basado en hash), y la idea de esta autenticación se basa en 3 conceptos principales.

Función de Hash, que sea difícil de romper y que sea conocida tanto por el cliente como el servidor.
Palabra secreta, también es compartida por el cliente y el servidor.
Datos que viajan de forma pública.

Cómo funciona

Lo que sucede es que el cliente sabiendo la función de hash y el secreto, toma esa información pública y con todo eso concatena y arma un mensaje que será enviado al servidor.

El servidor toma una información pública, el servidor ya conoce la información de hashing y el secreto, y vuelve a generar ese hash. Y luego, compara el recibido con el generado por el servidor, si coinciden la autenticación se produce, si no coinciden el servidor asume que ese usuario no está habilitado.

Para saber si ciertos encabezados estén en el array de encabezados que recibimos utilizamos HTTP_X_HASH, estos se suelen denotar con la letra X para decir que son encabezados no estándar.

!array_key_exists('HTTP_X_HASH')

list() → Nos deja asignar variables como si fueran un array, no es realmente una función, es un constructor del lenguaje. Este se utiliza para asignar una lista de variables en una sola operación.

Para crear un autenticación HMAC tenemos que:

Crear una condicional que si algunos de los encabezados no estándar que necesitamos no vienen datos por el cliente, muera el programa ahí.
Hace una lista de variables que contengan los encabezados no estándar que necesitamos.
Creamos una variable con nuestra palabra secreta
Y una variable que contenga el hash, dentro de la variable hacemos una función hash pasándole los parámetros del ID del usuario, el timestamp y la palabra secreta
Al final creamos otra condicional donde evaluamos si nuestro Hash no es igual al Hash que nos a dado el usuario. Si es verdad que no es igual, el programa termina en esa línea.

if (!array_key_exists('HTTP_X_HASH', $_SERVER) || !array_key_exists('HTTP_X_TIMESTAMP', $_SERVER) || !array_key_exists('HTTP_X_UID', $_SERVER) ) {
    die;
}

list( $hash, $uid, $timestamp ) = [
    $_SERVER['HTTP_X_HASH'],
    $_SERVER['HTTP_X_UID'],
    $_SERVER['HTTP_X_TIMESTAMP'],
];

$secret = 'Sh!! Es un secreto';

$newHash = sha1($uid . $timestamp . $secret);

if ( $newHash !== $hash) {
    die;
}

En nuestro caso para poder obtener un timestamp y un hash creamos otro archivo y escribimos:

<?php

$time = time();
echo "Time: $time" . PHP_EOL . "Hash: " . sha1($argv[1] . $time . 'Sh!! Es un secreto') . PHP_EOL ;

Y en la terminal, para pasar los datos escribimos:

curl http :// localhost:8000 /books -H 'X-HASH: 711b6f2914bb9e5b5ebef25d488b930f71bc5977' -H 'X-UID: 1' -H 'X-TIMESTAMP: 1609857500'

La -H es para indicar header, aquí pasamos los datos extras para los headers

diego andres guzman

student•

Lo que entiendo es que cuando el cliente se loguea por ejemplo el servidor le asigna el hash con el que va realizar las peticiones?, si es asi para que el cliente tenga a disposicion el has para enviarlo donde se almacena , en una cooky o en donde ?

Emerson Cedeño

student•

La implementación por sha1() podría reemplazarse con el uso de hash_hmac() de la siguiente forma:

De manera general (a implementar tanto en El Cliente como en El Server):

$algo = 'sha1';
$key = 'Sh!! No se lo cuentes a nadie!';

Del lado de El Cliente:

// ... considerar variables generales de arriba
$data = time();
$raw_output = false;

$hash_v2 = hash_hmac( $algo, $data, $key, $raw_output );

echo "Time: $data" . PHP_EOL . "Hash: " . $hash_v2 . PHP_EOL;

Del lado de El Server:

// ... considerar variables generales de arriba, y variable $timestamp del script server.php ...
$data = $timestamp;

$newHash_v2 = hash_hmac( $algo, $data, $key, $raw_output );

Patricio López Cabal

student•

Hola necesito ayuda para entender algunas cosas.

1-. ¿En qué momento el cliente usa la palabra secreta? por lo que ví solo se usa en los archivos del servidor (server.php y generate_hash.php).

2-. Si el cliente no necesita saber la palabra secreta entonces ¿Cualquiera podría autenticarse solo conociendo el nombre del archivo generador de hash (generate_hash.php) y el ID de usuario?

Gracias :)

Carlos Guillermo Coello Valenzuela

student•

Hola, 1) para el código que realizó el profesor (y para todos los códigos que tengan alguna noción de seguridad) la palabra secreta sólo es conocida por el servidor, el cliente sólo puede recibir los datos ya procesados (hash, timestamp) y devolverlos así como los recibió; 2) en este caso, es cierto que cuálquiera que sepa el nombre del generador del archivo y tenga acceso a él podría obtener el hash, por eso en aplicaciones de producción se debe de controlar a qué tiene acceso el cliente, el profesor sólo ejemplificó el uso de los hashes para autenticación. PD: Existen muchas formas de estructurar correctamente un sistema de autenticación. Saludos

Patricio López Cabal

student•

Gracias! entonces entiendo que puedo estructurar mi aplicación más allá del ejemplo de manera que la seguridad se consolide.

Johann Enrique Hurtado Salas

student•

Recuerden que si están en windows la consola no lee comillas simples si no dobles en pocas palabras quedaría de la siguiente manera el comando en consola:

curl http://localhost:8000/books -H "X-HASH:tuhas" -H "X-UID: tuid" -H "X-TIMESTAMP: tiempo"

Gustavo Alonso Medina Santiago

student•

Sí están usando windows y la consola les marca el siguiente error:

curl: (6) Could not resolve host:

Prueben a usar comillas dobles en los parámetros

"X_HASH: blablablabla"

Christian David Sánchez

student•

HMAC es un modo de autenticación de mensajes basado en hash. Ademas, es un mecanismo de autenticación de mensajes mediante funciones de hash cifradas.

Irvin Fiz

student•

HMAC basado en Hash de mensajes

Andres Evaristo Ruiz Gonzalez

student•

No entendi porque el $SERVER la variable X-HASH aparece como HTTP_X_HASH con un guio bajo al final.

Anderson Escobar

student•

Hola! tengo una duda... la variable $argv[1] que utiliza el hash del documento generate_hash.php es UNICA? no se puede reemplazar?

Kenneth Angulo L

student•

Ya tiene un ano esta pregunta. . Por si acaso alguien mas la esta leyendo, en el ejercicio del profesor esta variable $argv[1] corresponde al ID del usario. . En la practica esta informacion proviene de una base de datos y es variable, claro que si. en la clase usamos el numero 1, por simplicidad del ejercicio, solamente para aprender el concepto de como autenticar usando HMAC.

Jairo Niño

student•

No le veo mucho sentido al timestamp, no seria suficiente con el codigo secreto?

Autenticación Segura con Hashes y Clave Secreta en PHP

Comprender los objetivos y pre-requisitos del curso

Integración de Aplicaciones Web con PHP

Concepto y Herramientas Básicas de API en Programación

Conocer los conceptos principales de REST

Conceptos Básicos de HTTP y su Funcionamiento en Navegadores

Protocolo REST: Conceptos y Funciones Básicas

Aprender a consumir servicios REST

Consumo de APIs con PHP y manejo de peticiones HTTP

Aprender a producir servicios REST

Creación de un Servidor REST con PHP

Consulta de recursos específicos en PHP y URLs amigables

Incorporación de Datos a Servidor mediante API REST en PHP

Modificación de recursos en servidor con método HTTPS Push

Eliminar recursos con método DELETE en APIs RESTful

Conocer diferentes modos de restringir el acceso a las API Rest

Autenticación Básica HTTP en PHP: Implementación y Limitaciones

Autenticación Segura con Hashes y Clave Secreta en PHP

Autenticación con Access Touch: Implementación y Funcionamiento

Aprender a tratar errores en la comunicación vía REST

Manejo de Errores HTTP en Cliente y Servidor con PHP

Aprender a utilizar una API Rest para la comunicación FrontEnd/BackEnd

Comunicación Asíncrona en Aplicaciones de una Sola Página

JavaScript para Interacción con el DOM y AJAX

Comunicación con el Servidor Usando AJAX y JSON en JavaScript

Publicación y Configuración de Aplicaciones en Servidores Públicos

Conocer buenas prácticas del diseño de APIs REST

Buenas prácticas para diseñar APIs RESTful