Saltar al contenido
Apuntes FS(+)

Clase 28 - Token - Validaciones - Hash

#token #hash #validation #roles #authorization #authentication #backend

Tokens

  • Son un estándar para el intercambio de información segura entre dos partes.
  • Se utilizan para autenticar usuarios, autorizar acceso a recursos y rastrear transacciones.
  • Los tokens se pueden almacenar en la memoria, en una cookie o en una base de datos (localStorage, Indexed DB).
  • Los tokens se pueden encriptar para proteger la información confidencial.

JWT

JSON Web Token

  • Se compone de 3 partes, cabecera, carga y firma (header, payload, signature).
  • Se generan en el servidor con el fin de autenticar a los usuarios.
  • Se envían al cliente y se almacenan en el navegador.
  • Si el cliente quiere acceder a algún recurso con protección del servidor, debe proveer su JWT.

jwt

Authentication workflow

Authentication

Authentication workflow + Refresh

Authentication refresh

Validaciones

  • Aumentar la rigurosidad de nuestro backend.
  • Proteger la integridad y seguridad de los datos.

Validations

¿Cómo aplicar validaciones?

  • Utilizando JavaScript puro.
  • Manejando expresiones regulares.
  • Uso de bibliotecas externas.

Validations library

Bibliotecas externas

  • Características/Ventajas:
    • Sencillez
    • Personalización de mensajes de error
    • Validación de tipos complejos
    • Integración con otros frameworks

JOI, Yup, Zod, VineJs

  • JOI, VineJs, Zod, Yup
  • Definimos schemas y reglas de validación de forma sencilla.
// JOI
import Joi from 'joi';
const schema = Joi.object({
  name: Joi.string().required(),
  email: Joi.string().email().required(),
  age: Joi.number().min(18),
});


const { error, value } = schema.validate({ name: 'Ana', email: 'ana@email.com', age: 25 });


// ZOD
import { z } from 'zod';
const schema = z.object({
  name: z.string(),
  email: z.string().email(),
  age: z.number().min(18),
});


const result = schema.safeParse({ name: 'Ana', email: 'ana@email.com', age: 25 });


// Yup
import * as yup from 'yup';
const schema = yup.object({
  name: yup.string().required(),
  email: yup.string().email().required(),
  age: yup.number().min(18),
});


schema
  .validate({ name: 'Ana', email: 'ana@email.com', age: 25 })
  .then(valid => console.log('Valid!', valid))
  .catch(err => console.log('Validation error:', err.errors));


// VineJs
import vine from '@vinejs/vine'
const schema = vine.object({
  sku: vine.string(),
  price: vine.number().positive(),
  variants: vine.array(
    vine.object({
      name: vine.string(),
      type: vine.enum(['size', 'color']),
      value: vine.string(),
    })
  )
})


const data = getDataToValidate()
await vine.validate({ schema, data })

class-validator y class-transformer

  • Documentación de Nest

  • Para aprovechar que NestJS promueve una arquitectura basada en clases y decoradores, utilizaremos:

  • class-validator: Permite validar objetos basados en clases usando decoradores

    • Define reglas de validación de forma declarativa.
    • Integra fácilmente con el sistema de DTOs de NestJS.
    • Funciona automáticamente con ValidationPipe.

  • class-transformer: Convierte datos planos (como JSON del body) en instancias de clases, permitiendo que los decoradores de class-validator funcionen:

    • Transforma automáticamente datos entrantes al tipo correcto (por ejemplo, de string a number).
    • Se usa junto con ValidationPipe para que NestJS valide correctamente los DTOs.
class CreateUserDto {
  @IsEmail()
  email: string;


  @Length(6, 20)
  password: string;
}


// main.ts
app.useGlobalPipes(new ValidationPipe({ transform: true }));

Esto permite que:

  1. Nest convierta automáticamente el body en una instancia de la clase DTO (class-transformer).
  2. Valide esa instancia con las reglas de decoradores (class-validator).

Nota: también es posible usarlo en el app.module.ts

  • Recomendado si prefieres centralizar la configuración a través del sistema de módulos de NestJS
  • Permite inyectar dependencias si tu pipe personalizado lo requiere
app.module.ts
import { ValidationPipe } from '@nestjs/common';


@Module({
  imports: [MODULOS DEL PROYECTO],
  providers: [
    {
      provide: APP_PIPE,
      useClass: ValidationPipe,
    },
  ],
})
export class AppModule {}

Encriptación/Hash

  • Protección frente a brechas de seguridad.
  • Seguridad adicional para usuarios con contraseñas débiles.
  • Prevención de ataques de fuerza bruta.
  • Salting para mayor seguridad.
  • Generación de confianza para los usuarios.

bcrypt

Ejemplo