Estrategías de autenticación - Asegurando el API REST

Clase 31 de 35 • Curso de Node.js con Hapi

Resumen

Con el objeto de restringir el acceso a nuestra API para que solo los usuarios registrados en nuestra base de datos puedan hacer usa de ella, implementaremos una estrategia de autenticación básica de Hapi, para lo cual será necesario instalar un módulo adicional llamado hapi-auth-basic.

Una vez instalado, requerido y registrado el módulo hapi-auth-basic en el script de nuestro plugin de API REST, debemos implementarlo de la siguiente manera:

server.auth.strategy('simple', 'basic', { 'validate': validateAuth })

Donde simple es el nombre de la estrategia de autenticación, basic es el tipo (asociado al módulo que instalamos) y validateAuth es el método en el que definiremos la lógica de validación de los usuarios. Este último de forma muy similar a como lo hicimos antes en el método validate del modelo users en nuestra aplicación.

De esta manera, cuando se intente acceder a cualquiera de las rutas definidas para nuestra API REST, el navegador solicitará los datos de autenticación usuario y password y solo devolverá resultados útiles cuando las credenciales obtenidas de la autenticación sean válidas.

Nikolas Santis

student•

No funciona así de "simple" con el @hapi/basic, ya que no valida bien, puedes poner cualquier cosa y valida, porque se equivocó en usar la función de validar de users, que no era validate sino validateUser. Así lo hice:

No es necesario require el basic.

Registrar basic await server.register(require('@hapi/basic'))

Usamos la estrategia:

server.auth.strategy('simple', 'basic', { validate }) server.auth.default('simple')

Llamamos arriba los modelos de users. const users = require('../models/index').users

y finalmente la función validate.

`async function validate (req, username, password, h) { let user

  try {
    user = await users.validateUser({
      email: username,
      password: password
    })
  } catch (error) {
    server.log('error', error)
  }

  return {
    credentials: user || {},
    isValid: (user !== false)
  }
}`

Diego Ivan Padilla Bernal

student•

al final en el modelo users se implementó el método validateUser y no validate así que aunque ingresará datos erróneos ingresaría sin problema.

Fernando Cordero

student•

exactamente como dijo @nikosantis

Carlos Delgado

student•

el módulo de autenticación hapi-auth-basic está deprecado se debe usar @hapi/basic y se implementa de la siguiente forma:

await server.register(require('@hapi/basic'));
server.auth.strategy('simple', 'basic', { validate: validateAuth });

la función validateAuth queda igual que en la clase

Armando Rivera

student•

Alguien sabe como evitar que también pida login para las demás páginas? Por lo que tengo entendido sólo debería pedir login cuando accedemos a las rutas de la api no de home, register, login, etc

Annderson Rey Sánchez

student•

await server.register(require('@hapi/basic'));
    server.auth.strategy('simple', 'basic', { validate }) 
    server.auth.default('simple')

    async function validate (req, username, password, h) {
        let user
        try {
            user = await users.validateUser({
              email: username,
              password: password
            })
          } catch (error) {
            server.log('error', error)
          }
          return {
            credentials: user || {},
            isValid: (user !== false)
          }
    }

Francisco Garcia [C6]

student•

'use strict'

const Boom = require('boom')
const authBasic = require('hapi-auth-basic')
const Joi = require('joi')
const questions = require('../models/index').questions
const users = require('../models/index').users


module.exports = {
    name: 'api-rest',
    version: '1.0.0',
    async register (server, options) {
        const prefix = options.prefix || 'api'

        await server.register(authBasic)
        server.auth.strategy('simple', 'basic', { validate: validateAuth})

        server.route({
            method: 'GET',
            path: `/${prefix}/question/{key}`,
            options: {
                auth: 'simple',
                validate: {
                    params: {
                        key: Joi.string().required()
                    },
                    failAction: failValidation
                }
            },
            handler: async (req, h) =&gt; {
                let result
                try {
                    result = await questions.getOne(req.params.key)
                    if (!result) {
                        return Boom.notFound(`No se pudo encontrar la pregunta ${req.params.key}`)
                    }
                } catch (error) {
                    return Boom.badImplementation(`Hubo error buscando ${req.params.key} - ${error}`)   
                }
                return result
            }
        })

        server.route({
            method: 'GET',
            path: `/${prefix}/questions/{amount}`,
            options: {
                auth: 'simple',
                validate: {
                    params: {
                        amount: Joi.number().integer().min(1).max(20).required()
                    },
                    failAction: failValidation
                }
            },
            handler: async (req, h) =&gt; {
                let result
                try {
                    result = await questions.getLast(req.params.amount)
                    if (!result) {
                        return Boom.notFound(`No se pudo requperar las preguntas`)
                    }
                } catch (error) {
                    return Boom.badImplementation(`Hubo error buscando las preguntas - ${error}`)   
                }
                return result
            }
        })

        function failValidation (req, h, err) {
            return Boom.badRequest('Por favor use los paramtros correctos')
        }

        async function validateAuth(req, username, password, h) {
            let user
            try {
                user = await users.validate({ email: username, password: password })
            } catch (error) {
                server.log('error', error)
            }
            return {
                credentials: user || {},
                isValid: (user != false)
            }
        }
    }
}

Raziel Carvajal

student•

Hapi Auth Basic esta deprecado como dice en su documentación.

Pueden usar el equivalente '@hapi/basic' pero en version 5, ya que la version 6 que es la mas nueva, te pide Hapi v18.4, pero no me quiere instalar esa versión, es como si no existira.

Estrategías de autenticación - Asegurando el API REST

Introducción

Qué necesitas para este curso y qué aprenderás sobre Node.js con Hapi

Conceptos principales de hapi y creación de nuestro primer servidor

Breve historia y estado actual

Creando un sitio básico con Hapi

El objeto h, response y sus herramientas

Uso de plugins - Contenido estático

Plantillas con Handlebars

Renderizado de vistas - Layout y template del home

Recibiendo parámetros en una ruta POST - Creación del registro

Definir una mejor estructura con buenas prácticas en Hapi

Validando la información - Implementando Joi

Introducción a Firebase

Creando un modelo y guardando en firebase

Implementando el login y validación del usuario

Autenticación de usuarios - Cookies y estado

Manejando errores

Visualización de errores

Controlar el error 404 en inert y el error de validación

Repaso - Creación del modelo y controlador para preguntas

Repaso - Creación de las rutas para crear preguntas

Listar las últimas preguntas en el home

Aplicacion de conceptos avanzados

Enrutamiento avanzado - visualizando una pregunta

Enrutamiento avanzado - respondiendo una pregunta

Generando la lógica de la plantilla según si es creador o contribuidor

Métodos de servidor - respuesta correcta

Usando métodos de servidor

Manejo del caché - Agregando el home al caché

Procesamiento de archivos - Aceptando imágenes

Logging con Good - Monitoreando el servidor

Creación de plugins - Teoría

Creación de plugins - Implementando un API REST

Estrategías de autenticación - Asegurando el API REST

Seguridad básica - Asegurando el servidor contra CSRF

Seguridad básica - Asegurando el servidor contra XSS

Herramientas de desarrollo

Depuración del proyecto

Ecosistema de Hapi